// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;


type gtBool is uint256;
type gtUint8 is uint256;
type gtUint16 is uint256;
type gtUint32 is uint256;
type gtUint64 is uint256;

// we use a struct because user-defined value types can only be elementary value types
// 8 characters (in byte form) per cell and the final cell padded with zeroes if needed
struct gtString {
    gtUint64[] value;
}

type gtUint128 is uint256;
type gtUint256 is uint256;

type ctBool is uint256;
type ctUint8 is uint256;
type ctUint16 is uint256;
type ctUint32 is uint256;
type ctUint64 is uint256;

// we use a struct because user-defined value types can only be elementary value types
// 8 characters (in byte form) per cell and the final cell padded with zeroes if needed
struct ctString {
    ctUint64[] value;
}

type ctUint128 is uint256;
struct ctUint256 {
    ctUint128 ciphertextHigh;
    ctUint128 ciphertextLow;
}

struct itBool {
    ctBool ciphertext;
    bytes signature;
}
struct itUint8 {
    ctUint8 ciphertext;
    bytes signature;
}
struct itUint16 {
    ctUint16 ciphertext;
    bytes signature;
}
struct itUint32 {
    ctUint32 ciphertext;
    bytes signature;
}
struct itUint64 {
    ctUint64 ciphertext;
    bytes signature;
}
struct itString {
    ctString ciphertext;
    bytes[] signature;
}
struct itUint128 {
    ctUint128 ciphertext;
    bytes signature;
}
struct itUint256 {
    ctUint256 ciphertext;
    bytes signature;
}

struct utBool {
    ctBool ciphertext;
    ctBool userCiphertext;
}
struct utUint8 {
    ctUint8 ciphertext;
    ctUint8 userCiphertext;
}
struct utUint16 {
    ctUint16 ciphertext;
    ctUint16 userCiphertext;
}
struct utUint32 {
    ctUint32 ciphertext;
    ctUint32 userCiphertext;
}
struct utUint64 {
    ctUint64 ciphertext;
    ctUint64 userCiphertext;
}
struct utUint128 {
    ctUint128 ciphertext;
    ctUint128 userCiphertext;
}
struct utUint256 {
    ctUint256 ciphertext;
    ctUint256 userCiphertext;
}
struct utString {
    ctString ciphertext;
    ctString userCiphertext;
}


import "./MpcInterface.sol";


library MpcCore {

    enum MPC_TYPE {SBOOL_T , SUINT8_T , SUINT16_T, SUINT32_T ,SUINT64_T , SUINT128_T, SUINT256_T }
    enum ARGS {BOTH_SECRET , LHS_PUBLIC, RHS_PUBLIC  }
    uint public constant RSA_SIZE = 256; 

    function combineEnumsToBytes2(MPC_TYPE mpcType, ARGS argsType) internal pure returns (bytes2) {
        return bytes2(uint16(mpcType) << 8 | uint8(argsType));
    }

    function combineEnumsToBytes3(MPC_TYPE mpcType1, MPC_TYPE mpcType2, ARGS argsType) internal pure returns (bytes3) {
        return bytes3(uint24(mpcType1) << 16 | uint16(mpcType2) << 8 | uint8(argsType));
    }

    function combineEnumsToBytes4(MPC_TYPE mpcType1, MPC_TYPE mpcType2, MPC_TYPE mpcType3, ARGS argsType) internal pure returns (bytes4) {
        return bytes4(uint32(mpcType1) << 24 | uint24(mpcType2) << 16 | uint16(mpcType3) << 8 | uint8(argsType));
    }

    function combineEnumsToBytes5(MPC_TYPE mpcType1, MPC_TYPE mpcType2, MPC_TYPE mpcType3, MPC_TYPE mpcType4, ARGS argsType) internal pure returns (bytes5) {
        return bytes5(uint40(mpcType1) << 32 | uint32(mpcType2) << 24 | uint24(mpcType3) << 16 | uint16(mpcType4) << 8 | uint8(argsType));
    }

    function checkOverflow(gtBool bit) private {
        // To revert on overflow, the require statement must fail when the overflow bit is set.
        // Naturally, we would check that the overflow bit is 0.
        // However, directly requiring the bit to be 0 causes gas estimation to fail, as it always returns 1.
        // To handle this, we apply a NOT operation to the bit and require the result to be 1.
        //
        // Summary of all cases:
        //  1. **Overflow scenario**: The overflow bit is 1 → NOT operation returns 0 → require fails → transaction reverts.
        //  2. **No overflow**: The overflow bit is 0 → NOT operation returns 1 → require passes → transaction proceeds.
        //  3. **Gas estimation**: Decrypt always returns 1 during gas estimation → require passes → no impact on actual execution.
        gtBool notBit = not(bit);
        // revert on overflow
        require(decrypt(notBit) == true, "overflow error");
    }

    function checkRes8(gtBool bit, gtUint8 res) private returns (gtUint8) {
        // revert on overflow
        checkOverflow(bit);

        // return the output if there is no overflow
        return res;
    }

    function checkRes16(gtBool bit, gtUint16 res) private returns (gtUint16) {
        // revert on overflow
        checkOverflow(bit);

        // return the output if there is no overflow
        return res;
    }

    function checkRes32(gtBool bit, gtUint32 res) private returns (gtUint32) {
        // revert on overflow
        checkOverflow(bit);

        // return the output if there is no overflow
        return res;
    }

    function checkRes64(gtBool bit, gtUint64 res) private returns (gtUint64) {
        // revert on overflow
        checkOverflow(bit);

        // return the output if there is no overflow
        return res;
    }

    function checkRes128(gtBool bit, gtUint128 res) private returns (gtUint128) {
        // revert on overflow
        checkOverflow(bit);

        // return the output if there is no overflow
        return res;
    }

    function checkRes256(gtBool bit, gtUint256 res) private returns (gtUint256) {
        // revert on overflow
        checkOverflow(bit);

        // return the output if there is no overflow
        return res;
    }

    function getUserKey(bytes calldata signedEK, bytes calldata signature) internal returns (bytes memory keyShare0, bytes memory keyShare1) {
        bytes memory combined = new bytes(signature.length + signedEK.length);

        // Copy contents of signature into combined
        for (uint i = 0; i < signature.length; i++) {
            combined[i] = signature[i];
        }

        // Copy contents of _bytes2 into combined after _bytes1
        for (uint j = 0; j < signedEK.length; j++) {
            combined[signature.length + j] = signedEK[j];
        }
        bytes memory bothKeys = ExtendedOperations(address(MPC_PRECOMPILE)).GetUserKey(combined);
        bytes memory share0 = new bytes(RSA_SIZE);
        bytes memory share1 = new bytes(RSA_SIZE);

        // Copy the first key to the first share array
        for (uint i = 0; i < share0.length; i++) {
            share0[i] = bothKeys[i];
        }

        // Copy the second key to the second share array
        for (uint i = 0; i < share1.length; i++) {
            share1[i] = bothKeys[i + RSA_SIZE];
        }
        return (share0, share1);
    }

    function SHA256Fixed432BitInput(gtUint64 amount, gtUint64 seed1, gtUint64 seed2, address addr, uint64 padding1, uint16 padding2) internal returns (bytes memory result){
        return ExtendedOperations(address(MPC_PRECOMPILE)).SHA256Fixed432BitInput(gtUint64.unwrap(amount), gtUint64.unwrap(seed1), gtUint64.unwrap(seed2), uint256(padding1), uint256(padding2), abi.encodePacked(addr));
    }

// =========== 1 bit operations ==============

    function validateCiphertext(itBool memory input) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            ValidateCiphertext(bytes1(uint8(MPC_TYPE.SBOOL_T)), ctBool.unwrap(input.ciphertext), input.signature));
    }

    function onBoard(ctBool ct) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OnBoard(bytes1(uint8(MPC_TYPE.SBOOL_T)), ctBool.unwrap(ct)));
    }

    function offBoard(gtBool pt) internal returns (ctBool) {
          return ctBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoard(bytes1(uint8(MPC_TYPE.SBOOL_T)), gtBool.unwrap(pt)));
    }

    function offBoardToUser(gtBool pt, address addr) internal returns (ctBool) {
          return ctBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoardToUser(bytes1(uint8(MPC_TYPE.SBOOL_T)), gtBool.unwrap(pt), abi.encodePacked(addr)));
    }

    function offBoardCombined(gtBool pt, address addr) internal returns (utBool memory ut) {
        ut.ciphertext = offBoard(pt);
        ut.userCiphertext = offBoardToUser(pt, addr);
    }

    function setPublic(bool pt) internal returns (gtBool) {
        uint256 temp;
        temp = pt ? 1 : 0; 
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            SetPublic(bytes1(uint8(MPC_TYPE.SBOOL_T)), temp));
    }

    function rand() internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).Rand(bytes1(uint8(MPC_TYPE.SBOOL_T))));
    }

    function and(gtBool a, gtBool b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SBOOL_T, MPC_TYPE.SBOOL_T, ARGS.BOTH_SECRET), gtBool.unwrap(a), gtBool.unwrap(b)));
    }

    function or(gtBool a, gtBool b) internal returns (gtBool) {
          return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SBOOL_T, MPC_TYPE.SBOOL_T, ARGS.BOTH_SECRET), gtBool.unwrap(a), gtBool.unwrap(b)));
    }

    function xor(gtBool a, gtBool b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SBOOL_T, MPC_TYPE.SBOOL_T, ARGS.BOTH_SECRET), gtBool.unwrap(a), gtBool.unwrap(b)));
    }
    
    function eq(gtBool a, gtBool b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SBOOL_T, MPC_TYPE.SBOOL_T, ARGS.BOTH_SECRET), gtBool.unwrap(a), gtBool.unwrap(b)));
    }

    function ne(gtBool a, gtBool b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SBOOL_T, MPC_TYPE.SBOOL_T, ARGS.BOTH_SECRET), gtBool.unwrap(a), gtBool.unwrap(b)));
    }

    function decrypt(gtBool ct) internal returns (bool){
        uint256 temp = ExtendedOperations(address(MPC_PRECOMPILE)).
            Decrypt(bytes1(uint8(MPC_TYPE.SBOOL_T)), gtBool.unwrap(ct));
        return temp != 0;
    }

    function mux(gtBool bit, gtBool a, gtBool b) internal returns (gtBool){
         return  gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SBOOL_T, MPC_TYPE.SBOOL_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtBool.unwrap(a), gtBool.unwrap(b)));
    }

    function not(gtBool a) internal returns (gtBool){
         return  gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Not(bytes1(uint8(MPC_TYPE.SBOOL_T)), gtBool.unwrap(a)));
    }


 // =========== Operations with BOTH_SECRET parameter ===========
 // =========== 8 bit operations ==============

    function validateCiphertext(itUint8 memory input) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            ValidateCiphertext(bytes1(uint8(MPC_TYPE.SUINT8_T)), ctUint8.unwrap(input.ciphertext), input.signature));
    }

    function onBoard(ctUint8 ct) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OnBoard(bytes1(uint8(MPC_TYPE.SUINT8_T)), ctUint8.unwrap(ct)));
    }

    function offBoard(gtUint8 pt) internal returns (ctUint8) {
          return ctUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoard(bytes1(uint8(MPC_TYPE.SUINT8_T)), gtUint8.unwrap(pt)));
    }

    function offBoardToUser(gtUint8 pt, address addr) internal returns (ctUint8) {
          return ctUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoardToUser(bytes1(uint8(MPC_TYPE.SUINT8_T)), gtUint8.unwrap(pt), abi.encodePacked(addr)));
    }

    function offBoardCombined(gtUint8 pt, address addr) internal returns (utUint8 memory ut) {
        ut.ciphertext = offBoard(pt);
        ut.userCiphertext = offBoardToUser(pt, addr);
    }

    function setPublic8(uint8 pt) internal returns (gtUint8) {
          return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            SetPublic(bytes1(uint8(MPC_TYPE.SUINT8_T)), uint256(pt)));
    }

    function rand8() internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).Rand(bytes1(uint8(MPC_TYPE.SUINT8_T))));
    }

    function randBoundedBits8(uint8 numBits) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).RandBoundedBits(bytes1(uint8(MPC_TYPE.SUINT8_T)), numBits));
    }

    function add(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }
    
    function checkedAdd(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b));

        return checkRes8(gtBool.wrap(bit), gtUint8.wrap(res));
    }
    
    function checkedAddWithOverflowBit(gtUint8 a, gtUint8 b) internal returns (gtBool, gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function sub(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedSub(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b));

        return checkRes8(gtBool.wrap(bit), gtUint8.wrap(res));
    }
    
    function checkedSubWithOverflowBit(gtUint8 a, gtUint8 b) internal returns (gtBool, gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function mul(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedMul(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b));
        return checkRes8(gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint8 a, gtUint8 b) internal returns (gtBool, gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b));
        return (gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function div(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
          return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function rem(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function and(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function or(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
          return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function xor(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function eq(gtUint8 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function ne(gtUint8 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function ge(gtUint8 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function gt(gtUint8 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function le(gtUint8 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function lt(gtUint8 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function min(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function max(gtUint8 a, gtUint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function decrypt(gtUint8 ct) internal returns (uint8){
          return uint8(ExtendedOperations(address(MPC_PRECOMPILE)).
            Decrypt(bytes1(uint8(MPC_TYPE.SUINT8_T)), gtUint8.unwrap(ct)));
    }

    function mux(gtBool bit, gtUint8 a, gtUint8 b) internal returns (gtUint8){
         return  gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint8.unwrap(a), gtUint8.unwrap(b)));
    }

    function transfer(gtUint8 a, gtUint8 b, gtUint8 amount) internal returns (gtUint8, gtUint8, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint8.wrap(new_a), gtUint8.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint8 a, gtUint8 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint8, gtUint8, gtBool, gtUint8){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint8.wrap(new_a), gtUint8.wrap(new_b), gtBool.wrap(res), gtUint8.wrap(new_allowance));
    }


 // =========== 16 bit operations ==============

    function validateCiphertext(itUint16 memory input) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            ValidateCiphertext(bytes1(uint8(MPC_TYPE.SUINT16_T)), ctUint16.unwrap(input.ciphertext), input.signature));
    }

    function onBoard(ctUint16 ct) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OnBoard(bytes1(uint8(MPC_TYPE.SUINT16_T)), ctUint16.unwrap(ct)));
    }

    function offBoard(gtUint16 pt) internal returns (ctUint16) {
          return ctUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoard(bytes1(uint8(MPC_TYPE.SUINT16_T)), gtUint16.unwrap(pt)));
    }

    function offBoardToUser(gtUint16 pt, address addr) internal returns (ctUint16) {
          return ctUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoardToUser(bytes1(uint8(MPC_TYPE.SUINT16_T)), gtUint16.unwrap(pt), abi.encodePacked(addr)));
    }

    function offBoardCombined(gtUint16 pt, address addr) internal returns (utUint16 memory ut) {
        ut.ciphertext = offBoard(pt);
        ut.userCiphertext = offBoardToUser(pt, addr);
    }

    function setPublic16(uint16 pt) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            SetPublic(bytes1(uint8(MPC_TYPE.SUINT16_T)), uint256(pt)));
    }

    function rand16() internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).Rand(bytes1(uint8(MPC_TYPE.SUINT16_T))));
    }

    function randBoundedBits16(uint8 numBits) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).RandBoundedBits(bytes1(uint8(MPC_TYPE.SUINT16_T)), numBits));
    }

    function add(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedAdd(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }
    
    function checkedAddWithOverflowBit(gtUint16 a, gtUint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function sub(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedSub(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint16 a, gtUint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function mul(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedMul(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint16 a, gtUint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function div(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function rem(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function and(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function or(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function xor(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function eq(gtUint16 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function ne(gtUint16 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function ge(gtUint16 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function gt(gtUint16 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function le(gtUint16 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function lt(gtUint16 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }
    function min(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function max(gtUint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function decrypt(gtUint16 ct) internal returns (uint16){
          return uint16(ExtendedOperations(address(MPC_PRECOMPILE)).
            Decrypt(bytes1(uint8(MPC_TYPE.SUINT16_T)), gtUint16.unwrap(ct)));
    }

    function mux(gtBool bit, gtUint16 a, gtUint16 b) internal returns (gtUint16){
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint16.unwrap(a), gtUint16.unwrap(b)));
    }

    function transfer(gtUint16 a, gtUint16 b, gtUint16 amount) internal returns (gtUint16, gtUint16, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint16 a, gtUint16 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }



    // =========== 32 bit operations ==============

    function validateCiphertext(itUint32 memory input) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            ValidateCiphertext(bytes1(uint8(MPC_TYPE.SUINT32_T)), ctUint32.unwrap(input.ciphertext), input.signature));
    }

    function onBoard(ctUint32 ct) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OnBoard(bytes1(uint8(MPC_TYPE.SUINT32_T)), ctUint32.unwrap(ct)));
    }

    function offBoard(gtUint32 pt) internal returns (ctUint32) {
          return ctUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoard(bytes1(uint8(MPC_TYPE.SUINT32_T)), gtUint32.unwrap(pt)));
    }

    function offBoardToUser(gtUint32 pt, address addr) internal returns (ctUint32) {
          return ctUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoardToUser(bytes1(uint8(MPC_TYPE.SUINT32_T)), gtUint32.unwrap(pt), abi.encodePacked(addr)));
    }

    function offBoardCombined(gtUint32 pt, address addr) internal returns (utUint32 memory ut) {
        ut.ciphertext = offBoard(pt);
        ut.userCiphertext = offBoardToUser(pt, addr);
    }

    function setPublic32(uint32 pt) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            SetPublic(bytes1(uint8(MPC_TYPE.SUINT32_T)), uint256(pt)));
    }

    function rand32() internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).Rand(bytes1(uint8(MPC_TYPE.SUINT32_T))));
    }

    function randBoundedBits32(uint8 numBits) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).RandBoundedBits(bytes1(uint8(MPC_TYPE.SUINT32_T)), numBits));
    }

    function add(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function checkedAdd(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint32 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function sub(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function checkedSub(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint32 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function mul(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function checkedMul(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b));
        
        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint32 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b));
        
        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function div(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function rem(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function and(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function or(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function xor(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function eq(gtUint32 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function ne(gtUint32 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function ge(gtUint32 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function gt(gtUint32 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function le(gtUint32 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function lt(gtUint32 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function min(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function max(gtUint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function decrypt(gtUint32 ct) internal returns (uint32){
          return uint32(ExtendedOperations(address(MPC_PRECOMPILE)).
            Decrypt(bytes1(uint8(MPC_TYPE.SUINT32_T)), gtUint32.unwrap(ct)));
    }

    function mux(gtBool bit, gtUint32 a, gtUint32 b) internal returns (gtUint32){
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint32.unwrap(a), gtUint32.unwrap(b)));
    }

    function transfer(gtUint32 a, gtUint32 b, gtUint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }



// =========== 64 bit operations ==============

    function validateCiphertext(itUint64 memory input) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            ValidateCiphertext(bytes1(uint8(MPC_TYPE.SUINT64_T)), ctUint64.unwrap(input.ciphertext), input.signature));
    }

    function onBoard(ctUint64 ct) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OnBoard(bytes1(uint8(MPC_TYPE.SUINT64_T)), ctUint64.unwrap(ct)));
    }

    function offBoard(gtUint64 pt) internal returns (ctUint64) {
          return ctUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoard(bytes1(uint8(MPC_TYPE.SUINT64_T)), gtUint64.unwrap(pt)));
    }

    function offBoardToUser(gtUint64 pt, address addr) internal returns (ctUint64) {
          return ctUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoardToUser(bytes1(uint8(MPC_TYPE.SUINT64_T)), gtUint64.unwrap(pt), abi.encodePacked(addr)));
    }

    function offBoardCombined(gtUint64 pt, address addr) internal returns (utUint64 memory ut) {
        ut.ciphertext = offBoard(pt);
        ut.userCiphertext = offBoardToUser(pt, addr);
    }

    function setPublic64(uint64 pt) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            SetPublic(bytes1(uint8(MPC_TYPE.SUINT64_T)), uint256(pt)));
    }

    function rand64() internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).Rand(bytes1(uint8(MPC_TYPE.SUINT64_T))));
    }

    function randBoundedBits64(uint8 numBits) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).RandBoundedBits(bytes1(uint8(MPC_TYPE.SUINT64_T)), numBits));
    }

    function add(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function checkedAdd(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint64 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function sub(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function checkedSub(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint64 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function mul(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function checkedMul(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint64 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function div(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function rem(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function and(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function or(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function xor(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function eq(gtUint64 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function ne(gtUint64 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function ge(gtUint64 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function gt(gtUint64 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function le(gtUint64 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function lt(gtUint64 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function min(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function max(gtUint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function decrypt(gtUint64 ct) internal returns (uint64){
          return uint64(ExtendedOperations(address(MPC_PRECOMPILE)).
            Decrypt(bytes1(uint8(MPC_TYPE.SUINT64_T)), gtUint64.unwrap(ct)));
    }

    function mux(gtBool bit, gtUint64 a, gtUint64 b) internal returns (gtUint64){
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint64.unwrap(a), gtUint64.unwrap(b)));
    }

    function transfer(gtUint64 a, gtUint64 b, gtUint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // =========== 128 bit operations ==============

    function validateCiphertext(itUint128 memory input) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            ValidateCiphertext(bytes1(uint8(MPC_TYPE.SUINT128_T)), ctUint128.unwrap(input.ciphertext), input.signature));
    }

    function onBoard(ctUint128 ct) internal returns (gtUint128) {
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OnBoard(bytes1(uint8(MPC_TYPE.SUINT128_T)), ctUint128.unwrap(ct)));
    }

    function offBoard(gtUint128 pt) internal returns (ctUint128) {
          return ctUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoard(bytes1(uint8(MPC_TYPE.SUINT128_T)), gtUint128.unwrap(pt)));
    }

    function offBoardToUser(gtUint128 pt, address addr) internal returns (ctUint128) {
          return ctUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoardToUser(bytes1(uint8(MPC_TYPE.SUINT128_T)), gtUint128.unwrap(pt), abi.encodePacked(addr)));
    }

    function offBoardCombined(gtUint128 pt, address addr) internal returns (utUint128 memory ut) {
        ut.ciphertext = offBoard(pt);
        ut.userCiphertext = offBoardToUser(pt, addr);
    }

    function setPublic128(uint128 pt) internal returns (gtUint128) {
          return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            SetPublic(bytes1(uint8(MPC_TYPE.SUINT128_T)), uint256(pt)));
    }

    function rand128() internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).Rand(bytes1(uint8(MPC_TYPE.SUINT128_T))));
    }

    function randBoundedBits128(uint8 numBits) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).RandBoundedBits(bytes1(uint8(MPC_TYPE.SUINT128_T)), numBits));
    }

    function decrypt(gtUint128 ct) internal returns (uint128){
          return uint128(ExtendedOperations(address(MPC_PRECOMPILE)).
            Decrypt(bytes1(uint8(MPC_TYPE.SUINT128_T)), gtUint128.unwrap(ct)));
    }

    function transfer(gtUint128 a, gtUint128 b, gtUint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function add(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function checkedAdd(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint128 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function sub(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function checkedSub(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint128 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function mul(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function checkedMul(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint128 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function div(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function rem(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function and(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function or(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function xor(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function not(gtUint128 a) internal returns (gtUint128) {
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Not(bytes1(uint8(MPC_TYPE.SUINT128_T)), gtUint128.unwrap(a)));
    }

    function eq(gtUint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function ne(gtUint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function ge(gtUint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function gt(gtUint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function le(gtUint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function lt(gtUint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function min(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function max(gtUint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }

    function mux(gtBool bit, gtUint128 a, gtUint128 b) internal returns (gtUint128){
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint128.unwrap(a), gtUint128.unwrap(b)));
    }



    // =========== 256 bit operations ==============

    function validateCiphertext(itUint256 memory input) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            ValidateCiphertext(bytes1(uint8(MPC_TYPE.SUINT256_T)), ctUint128.unwrap(input.ciphertext.ciphertextHigh), ctUint128.unwrap(input.ciphertext.ciphertextLow), input.signature));
    }

    function onBoard(ctUint256 memory ct) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            OnBoard(bytes1(uint8(MPC_TYPE.SUINT256_T)), ctUint128.unwrap(ct.ciphertextHigh), ctUint128.unwrap(ct.ciphertextLow)));
    }

    function offBoard(gtUint256 pt) internal returns (ctUint256 memory) {
        (uint256 ctHigh, uint256 ctLow) = ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoard256(bytes1(uint8(MPC_TYPE.SUINT256_T)), gtUint256.unwrap(pt));
        ctUint256 memory ct = ctUint256({ciphertextHigh: ctUint128.wrap(ctHigh), ciphertextLow: ctUint128.wrap(ctLow)});
        return ct;
    }

    function offBoardToUser(gtUint256 pt, address addr) internal returns (ctUint256 memory) {
        (uint256 ctHigh, uint256 ctLow) = ExtendedOperations(address(MPC_PRECOMPILE)).
            OffBoardToUser256(bytes1(uint8(MPC_TYPE.SUINT256_T)), gtUint256.unwrap(pt), abi.encodePacked(addr));
        ctUint256 memory ct = ctUint256({ciphertextHigh: ctUint128.wrap(ctHigh), ciphertextLow: ctUint128.wrap(ctLow)});
        return ct;
    }

    function offBoardCombined(gtUint256 pt, address addr) internal returns (utUint256 memory ut) {
        ut.ciphertext = offBoard(pt);
        ut.userCiphertext = offBoardToUser(pt, addr);
    }

    function setPublic256(uint256 pt) internal returns (gtUint256) {
          return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            SetPublic(bytes1(uint8(MPC_TYPE.SUINT256_T)), uint256(pt)));
    }

    function rand256() internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).Rand(bytes1(uint8(MPC_TYPE.SUINT256_T))));
    }

    function randBoundedBits256(uint8 numBits) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).RandBoundedBits(bytes1(uint8(MPC_TYPE.SUINT256_T)), numBits));
    }

    function decrypt(gtUint256 ct) internal returns (uint256){
        return uint256(ExtendedOperations(address(MPC_PRECOMPILE)).
            Decrypt(bytes1(uint8(MPC_TYPE.SUINT256_T)), gtUint256.unwrap(ct)));
    }

    function transfer(gtUint256 a, gtUint256 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function add(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function checkedAdd(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint256 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function sub(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function checkedSub(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint256 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function mul(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function checkedMul(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint256 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function div(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function rem(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function and(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function or(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function xor(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function not(gtUint256 a) internal returns (gtUint256) {
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Not(bytes1(uint8(MPC_TYPE.SUINT256_T)), gtUint256.unwrap(a)));
    }

    function eq(gtUint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function ne(gtUint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function ge(gtUint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function gt(gtUint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function le(gtUint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function lt(gtUint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function min(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function max(gtUint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }

    function mux(gtBool bit, gtUint256 a, gtUint256 b) internal returns (gtUint256){
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint256.unwrap(a), gtUint256.unwrap(b)));
    }




// =========== Operations with LHS_PUBLIC parameter ===========
 // =========== 8 bit operations ==============

    function add(uint8 a, gtUint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function checkedAdd(uint8 a, gtUint8 b) internal returns (gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b));

        return checkRes8(gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function checkedAddWithOverflowBit(uint8 a, gtUint8 b) internal returns (gtBool, gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function sub(uint8 a, gtUint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function checkedSub(uint8 a, gtUint8 b) internal returns (gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b));

        return checkRes8(gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function checkedSubWithOverflowBit(uint8 a, gtUint8 b) internal returns (gtBool, gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function mul(uint8 a, gtUint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function checkedMul(uint8 a, gtUint8 b) internal returns (gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b));

        return checkRes8(gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function checkedMulWithOverflowBit(uint8 a, gtUint8 b) internal returns (gtBool, gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function div(uint8 a, gtUint8 b) internal returns (gtUint8) {
          return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }
    function rem(uint8 a, gtUint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function and(uint8 a, gtUint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function or(uint8 a, gtUint8 b) internal returns (gtUint8) {
          return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function xor(uint8 a, gtUint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function eq(uint8 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function ne(uint8 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function ge(uint8 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function gt(uint8 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function le(uint8 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function lt(uint8 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function min(uint8 a, gtUint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function max(uint8 a, gtUint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), uint256(a), gtUint8.unwrap(b)));
    }

    function mux(gtBool bit, uint8 a, gtUint8 b) internal returns (gtUint8){
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtBool.unwrap(bit), uint256(a), gtUint8.unwrap(b)));
    }


 // =========== 16 bit operations ==============

    function add(uint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function checkedAdd(uint16 a, gtUint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedAddWithOverflowBit(uint16 a, gtUint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function sub(uint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function checkedSub(uint16 a, gtUint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedSubWithOverflowBit(uint16 a, gtUint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function mul(uint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function checkedMul(uint16 a, gtUint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedMulWithOverflowBit(uint16 a, gtUint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function div(uint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function rem(uint16 a, gtUint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function and(uint16 a, gtUint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function or(uint16 a, gtUint16 b) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function xor(uint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function eq(uint16 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function ne(uint16 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function ge(uint16 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function gt(uint16 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function le(uint16 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function lt(uint16 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function min(uint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function max(uint16 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), uint256(a), gtUint16.unwrap(b)));
    }

    function mux(gtBool bit, uint16 a, gtUint16 b) internal returns (gtUint16){
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtBool.unwrap(bit), uint256(a), gtUint16.unwrap(b)));
    }


    // =========== 32 bit operations ==============

    function add(uint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function checkedAdd(uint32 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedAddWithOverflowBit(uint32 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function sub(uint32 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function checkedSub(uint32 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedSubWithOverflowBit(uint32 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function mul(uint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function checkedMul(uint32 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedMulWithOverflowBit(uint32 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function div(uint32 a, gtUint32 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function rem(uint32 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function and(uint32 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function or(uint32 a, gtUint32 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function xor(uint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function eq(uint32 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function ne(uint32 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function ge(uint32 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function gt(uint32 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function le(uint32 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function lt(uint32 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function min(uint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function max(uint32 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), uint256(a), gtUint32.unwrap(b)));
    }

    function mux(gtBool bit, uint32 a, gtUint32 b) internal returns (gtUint32){
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtBool.unwrap(bit), uint256(a), gtUint32.unwrap(b)));
    }


// =========== 64 bit operations ==============

    function add(uint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function checkedAdd(uint64 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAddWithOverflowBit(uint64 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function sub(uint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function checkedSub(uint64 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSubWithOverflowBit(uint64 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function mul(uint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function checkedMul(uint64 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMulWithOverflowBit(uint64 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function div(uint64 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function rem(uint64 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function and(uint64 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function or(uint64 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function xor(uint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function eq(uint64 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function ne(uint64 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function ge(uint64 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function gt(uint64 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function le(uint64 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function lt(uint64 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function min(uint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function max(uint64 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), uint256(a), gtUint64.unwrap(b)));
    }

    function mux(gtBool bit, uint64 a, gtUint64 b) internal returns (gtUint64){
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtBool.unwrap(bit), uint256(a), gtUint64.unwrap(b)));
    }

    // =========== 128 bit operations ==============

    function add(uint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function checkedAdd(uint128 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(uint128 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function sub(uint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function checkedSub(uint128 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(uint128 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function mul(uint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function checkedMul(uint128 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(uint128 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function div(uint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function rem(uint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function and(uint128 a, gtUint128 b) internal returns (gtUint128) {
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function or(uint128 a, gtUint128 b) internal returns (gtUint128) {
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function xor(uint128 a, gtUint128 b) internal returns (gtUint128) {
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function eq(uint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function ne(uint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function ge(uint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function gt(uint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function le(uint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function lt(uint128 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function min(uint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function max(uint128 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), uint256(a), gtUint128.unwrap(b)));
    }

    function mux(gtBool bit, uint128 a, gtUint128 b) internal returns (gtUint128){
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtBool.unwrap(bit), uint256(a), gtUint128.unwrap(b)));
    }


    // =========== 256 bit operations ==============

    function add(uint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function checkedAdd(uint256 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(uint256 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function sub(uint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function checkedSub(uint256 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(uint256 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function mul(uint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function checkedMul(uint256 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(uint256 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function div(uint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function rem(uint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function and(uint256 a, gtUint256 b) internal returns (gtUint256) {
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function or(uint256 a, gtUint256 b) internal returns (gtUint256) {
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function xor(uint256 a, gtUint256 b) internal returns (gtUint256) {
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function eq(uint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function ne(uint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function ge(uint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function gt(uint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function le(uint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function lt(uint256 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function min(uint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function max(uint256 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), uint256(a), gtUint256.unwrap(b)));
    }

    function mux(gtBool bit, uint256 a, gtUint256 b) internal returns (gtUint256){
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtBool.unwrap(bit), uint256(a), gtUint256.unwrap(b)));
    }


 // =========== Operations with RHS_PUBLIC parameter ===========
 // =========== 8 bit operations ==============

    function add(gtUint8 a, uint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function checkedAdd(gtUint8 a, uint8 b) internal returns (gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b));

        return checkRes8(gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint8 a, uint8 b) internal returns (gtBool, gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function sub(gtUint8 a, uint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function checkedSub(gtUint8 a, uint8 b) internal returns (gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b));

        return checkRes8(gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint8 a, uint8 b) internal returns (gtBool, gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function mul(gtUint8 a, uint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function checkedMul(gtUint8 a, uint8 b) internal returns (gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b));

        return checkRes8(gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint8 a, uint8 b) internal returns (gtBool, gtUint8) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint8.wrap(res));
    }

    function div(gtUint8 a, uint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function rem(gtUint8 a, uint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function and(gtUint8 a, uint8 b) internal returns (gtUint8) {
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function or(gtUint8 a, uint8 b) internal returns (gtUint8) {
          return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function xor(gtUint8 a, uint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function shl(gtUint8 a, uint8 b) internal returns (gtUint8) {
          return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function shr(gtUint8 a, uint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function eq(gtUint8 a, uint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function ne(gtUint8 a, uint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }
    
    function ge(gtUint8 a, uint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function gt(gtUint8 a, uint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function le(gtUint8 a, uint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function lt(gtUint8 a, uint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function min(gtUint8 a, uint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function max(gtUint8 a, uint8 b) internal returns (gtUint8) {
        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
    }

    function mux(gtBool bit, gtUint8 a, uint8 b) internal returns (gtUint8){
         return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtBool.unwrap(bit), gtUint8.unwrap(a), uint256(b)));
    }

 // =========== 16 bit operations ==============

    function add(gtUint16 a, uint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function checkedAdd(gtUint16 a, uint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint16 a, uint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function sub(gtUint16 a, uint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function checkedSub(gtUint16 a, uint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint16 a, uint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function mul(gtUint16 a, uint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function checkedMul(gtUint16 a, uint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint16 a, uint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function div(gtUint16 a, uint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function rem(gtUint16 a, uint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function and(gtUint16 a, uint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function or(gtUint16 a, uint16 b) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function xor(gtUint16 a, uint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function shl(gtUint16 a, uint8 b) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function shr(gtUint16 a, uint8 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function eq(gtUint16 a, uint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function ne(gtUint16 a, uint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function ge(gtUint16 a, uint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function gt(gtUint16 a, uint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function le(gtUint16 a, uint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function lt(gtUint16 a, uint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function min(gtUint16 a, uint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function max(gtUint16 a, uint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
    }

    function mux(gtBool bit, gtUint16 a, uint16 b) internal returns (gtUint16){
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtBool.unwrap(bit), gtUint16.unwrap(a), uint256(b)));
    }


    // =========== 32 bit operations ==============

    function add(gtUint32 a, uint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function checkedAdd(gtUint32 a, uint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint32 a, uint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function sub(gtUint32 a, uint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function checkedSub(gtUint32 a, uint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint32 a, uint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function mul(gtUint32 a, uint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function checkedMul(gtUint32 a, uint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint32 a, uint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function div(gtUint32 a, uint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function rem(gtUint32 a, uint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function and(gtUint32 a, uint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }
    function or(gtUint32 a, uint32 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function xor(gtUint32 a, uint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function shl(gtUint32 a, uint8 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function shr(gtUint32 a, uint8 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function eq(gtUint32 a, uint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function ne(gtUint32 a, uint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function ge(gtUint32 a, uint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function gt(gtUint32 a, uint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function le(gtUint32 a, uint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function lt(gtUint32 a, uint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function min(gtUint32 a, uint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function max(gtUint32 a, uint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
    }

    function mux(gtBool bit, gtUint32 a, uint32 b) internal returns (gtUint32){
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtBool.unwrap(bit), gtUint32.unwrap(a), uint256(b)));
    }
    

// =========== 64 bit operations ==============

    function add(gtUint64 a, uint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function checkedAdd(gtUint64 a, uint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint64 a, uint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function sub(gtUint64 a, uint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function checkedSub(gtUint64 a, uint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint64 a, uint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function mul(gtUint64 a, uint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function checkedMul(gtUint64 a, uint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint64 a, uint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function div(gtUint64 a, uint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function rem(gtUint64 a, uint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function and(gtUint64 a, uint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function or(gtUint64 a, uint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function xor(gtUint64 a, uint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function shl(gtUint64 a, uint8 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function shr(gtUint64 a, uint8 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function eq(gtUint64 a, uint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function ne(gtUint64 a, uint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function ge(gtUint64 a, uint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function gt(gtUint64 a, uint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function le(gtUint64 a, uint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function lt(gtUint64 a, uint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function min(gtUint64 a, uint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function max(gtUint64 a, uint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
    }

    function mux(gtBool bit, gtUint64 a, uint64 b) internal returns (gtUint64){
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtBool.unwrap(bit), gtUint64.unwrap(a), uint256(b)));
    }

    // =========== String operations ============

    function validateCiphertext(itString memory input) internal returns (gtString memory) {
        uint256 len_ = input.signature.length;

        require(input.ciphertext.value.length == len_, "MPC_CORE: INVALID_INPUT_TEXT");

        gtString memory gt_ = gtString(new gtUint64[](len_));

        itUint64 memory it_;

        for (uint256 i = 0; i < len_; ++i) {
            it_.ciphertext = input.ciphertext.value[i];
            it_.signature = input.signature[i];

            gt_.value[i] = validateCiphertext(it_);
        }

        return gt_;
    }

    function onBoard(ctString memory ct) internal returns (gtString memory) {
        uint256 len_ = ct.value.length;

        gtString memory gt_ = gtString(new gtUint64[](len_));

        for (uint256 i = 0; i < len_; ++i) {
            gt_.value[i] = onBoard(ct.value[i]);
        }

        return gt_;
    }

    function offBoard(gtString memory pt) internal returns (ctString memory) {
        uint256 len_ = pt.value.length;

        ctString memory ct_ = ctString(new ctUint64[](len_));

        for (uint256 i = 0; i < len_; ++i) {
            ct_.value[i] = offBoard(pt.value[i]);
        }

        return ct_;
    }

    function offBoardToUser(gtString memory pt, address addr) internal returns (ctString memory) {
        uint256 len_ = pt.value.length;

        ctString memory ct_ = ctString(new ctUint64[](len_));

        for (uint256 i = 0; i < len_; ++i) {
            ct_.value[i] = offBoardToUser(pt.value[i], addr);
        }

        return ct_;
    }

    function offBoardCombined(gtString memory pt, address addr) internal returns (utString memory ut) {
        ut.ciphertext = offBoard(pt);
        ut.userCiphertext = offBoardToUser(pt, addr);
    }

    function setPublicString(string memory pt) internal returns (gtString memory) {
        bytes memory strBytes_ = bytes(pt);
        uint256 len_ = strBytes_.length;
        uint256 count_ = (len_ + 7) / 8; // Number of bytes8 elements needed

        gtString memory result_ = gtString(new gtUint64[](count_));

        bytes8 cell_;

        for (uint256 i = 0; i < count_ * 8; ++i) {
            if (i % 8 == 0) {
                cell_ = bytes8(0);
            } else {
                cell_ <<= 8;
            }

            if (i < len_) {
                cell_ |= bytes8(strBytes_[i]) >> 56;
            }

            if (i % 8 == 7) {
                result_.value[i / 8] = setPublic64(uint64(cell_));
            }
        }

        return result_;
    }

    function decrypt(gtString memory ct) internal returns (string memory){
        uint256 len_ = ct.value.length;
        bytes memory result_ = new bytes(len_ * 8);

        bytes8 temp_;

        uint256 resultIndex;
        
        for (uint256 i = 0; i < len_; ++i) {
            temp_ = bytes8(decrypt(ct.value[i]));

            assembly {
                // Copy the bytes directly into the result array using assembly.
                mstore(add(result_, add(0x20, resultIndex)), temp_)
            }

            resultIndex += 8;
        }

        return string(result_);
    }

    function eq(gtString memory a, gtString memory b) internal returns (gtBool) {
        uint256 len = a.value.length;

        // note that we are not leaking information since the array length is visible to all
        if (len != b.value.length) return setPublic(false);

        gtBool result_ = eq(a.value[0], b.value[0]);

        for (uint256 i = 1; i < len; ++i) {
            result_ = and(result_, eq(a.value[i], b.value[i]));
        }

        return result_;
    }

    function ne(gtString memory a, gtString memory b) internal returns (gtBool) {
        uint256 len = a.value.length;

        // note that we are not leaking information since the array length is visible to all
        if (len != b.value.length) return setPublic(true);

        gtBool result_ = ne(a.value[0], b.value[0]);

        for (uint256 i = 1; i < len; ++i) {
            result_ = or(result_, ne(a.value[i], b.value[i]));
        }

        return result_;
    }

    // =========== 128 bit operations ==============

    function add(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function checkedAdd(gtUint128 a, uint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint128 a, uint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function sub(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function checkedSub(gtUint128 a, uint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint128 a, uint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function mul(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function checkedMul(gtUint128 a, uint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint128 a, uint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function div(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function rem(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function and(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function or(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function xor(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function eq(gtUint128 a, uint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function ne(gtUint128 a, uint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function ge(gtUint128 a, uint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function gt(gtUint128 a, uint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function le(gtUint128 a, uint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function lt(gtUint128 a, uint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function min(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function max(gtUint128 a, uint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function shl(gtUint128 a, uint8 b) internal returns (gtUint128) {
          return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function shr(gtUint128 a, uint8 b) internal returns (gtUint128) {
          return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint128.unwrap(a), uint256(b)));
    }

    function mux(gtBool bit, gtUint128 a, uint128 b) internal returns (gtUint128){
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.RHS_PUBLIC), gtBool.unwrap(bit), gtUint128.unwrap(a), uint256(b)));
    }


    // 256 bit operations

    
    function add(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function checkedAdd(gtUint256 a, uint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint256 a, uint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function sub(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function checkedSub(gtUint256 a, uint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint256 a, uint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function mul(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function checkedMul(gtUint256 a, uint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint256 a, uint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function div(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function rem(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function and(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function or(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function xor(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function eq(gtUint256 a, uint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function ne(gtUint256 a, uint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function ge(gtUint256 a, uint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function gt(gtUint256 a, uint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function le(gtUint256 a, uint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function lt(gtUint256 a, uint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function min(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function max(gtUint256 a, uint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function shl(gtUint256 a, uint8 b) internal returns (gtUint256) {
          return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function shr(gtUint256 a, uint8 b) internal returns (gtUint256) {
          return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint256.unwrap(a), uint256(b)));
    }

    function mux(gtBool bit, gtUint256 a, uint256 b) internal returns (gtUint256){
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.RHS_PUBLIC), gtBool.unwrap(bit), gtUint256.unwrap(a), uint256(b)));
    }


    // In the context of a transfer, scalar balances are irrelevant;
	// The only possibility for a scalar value is within the "amount" parameter.
	// Therefore, in this scenario, LHS_PUBLIC signifies a scalar amount, not balance1.

    function transfer(gtUint8 a, gtUint8 b, uint8 amount) internal returns (gtUint8, gtUint8, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint8.unwrap(b), uint256(amount));
        return (gtUint8.wrap(new_a), gtUint8.wrap(new_b), gtBool.wrap(res));
    }
    
    function transfer(gtUint16 a, gtUint16 b, uint16 amount) internal returns (gtUint16, gtUint16, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint16.unwrap(b), uint256(amount));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint16 b, uint16 amount) internal returns (gtUint16, gtUint16, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint16.unwrap(b), uint256(amount));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint8 b, uint16 amount) internal returns (gtUint16, gtUint16, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint8.unwrap(b), uint256(amount));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint32 b, uint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint32.unwrap(b), uint256(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint32 b, uint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint32.unwrap(b), uint256(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint8 b, uint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint8.unwrap(b), uint256(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint32 b, uint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint32.unwrap(b), uint256(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint16 b, uint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint16.unwrap(b), uint256(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint64 b, uint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint64.unwrap(b), uint256(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint64 b, uint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint64.unwrap(b), uint256(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint8 b, uint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint8.unwrap(b), uint256(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint64 b, uint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint64.unwrap(b), uint256(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint16 b, uint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint16.unwrap(b), uint256(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint64 b, uint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint64.unwrap(b), uint256(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint32 b, uint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint32.unwrap(b), uint256(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint128 b, uint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint128.unwrap(b), uint256(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint128 b, uint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint128.unwrap(b), uint256(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint8 b, uint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint8.unwrap(b), uint256(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint128 b, uint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint128.unwrap(b), uint256(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint16 b, uint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint16.unwrap(b), uint256(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint128 b, uint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint128.unwrap(b), uint256(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint32 b, uint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint32.unwrap(b), uint256(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint128 b, uint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint128.unwrap(b), uint256(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint64 b, uint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint64.unwrap(b), uint256(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    // =========== Transfer functions for public amount ==============

    function transfer(gtUint256 a, gtUint256 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint256.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint256 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint256.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint8 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint8.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint256 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint256.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint16 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint16.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint256 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint256.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint32 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint32.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint256 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint256.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint64 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint64.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint256 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint256.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint128 b, uint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint128.unwrap(b), uint256(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint8 a, gtUint8 b, uint8 amount, gtUint8 allowance) internal returns (gtUint8, gtUint8, gtBool, gtUint8){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint8.wrap(new_a), gtUint8.wrap(new_b), gtBool.wrap(res), gtUint8.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint16 b, uint16 amount, gtUint16 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint16 b, uint16 amount, gtUint16 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint8 b, uint16 amount, gtUint16 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    // Allowance with 8 bits
    function transferWithAllowance(gtUint16 a, gtUint16 b, uint16 amount, gtUint8 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint16 b, uint16 amount, gtUint8 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint8 b, uint16 amount, gtUint8 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, uint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint32 b, uint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, uint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, uint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, uint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    // Allowance with 8 bits
    function transferWithAllowance(gtUint32 a, gtUint32 b, uint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint32 b, uint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, uint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, uint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, uint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    // Allowance with 16 bits
    function transferWithAllowance(gtUint32 a, gtUint32 b, uint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint32 b, uint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, uint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, uint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, uint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, uint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, uint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, uint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, uint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, uint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, uint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, uint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 8 bits
    function transferWithAllowance(gtUint64 a, gtUint64 b, uint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, uint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, uint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, uint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, uint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, uint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, uint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 16 bits
    function transferWithAllowance(gtUint64 a, gtUint64 b, uint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, uint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, uint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, uint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, uint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, uint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, uint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 32 bits
    function transferWithAllowance(gtUint64 a, gtUint64 b, uint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, uint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, uint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, uint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, uint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, uint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, uint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // =========== Transfer With allowance 128 bit ==============

    function transferWithAllowance(gtUint128 a, gtUint128 b, uint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint128 b, uint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint128 b, uint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint128 b, uint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint128 b, uint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint8 a, gtUint128 b, uint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint8 b, uint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint8 a, gtUint128 b, uint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint8 b, uint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint8 a, gtUint128 b, uint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint8 b, uint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint8 a, gtUint128 b, uint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint8 b, uint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint8 a, gtUint128 b, uint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint8 b, uint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint16 a, gtUint128 b, uint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint16 b, uint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint16 a, gtUint128 b, uint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint16 b, uint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint16 a, gtUint128 b, uint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint16 b, uint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint16 a, gtUint128 b, uint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint16 b, uint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint16 a, gtUint128 b, uint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint16 b, uint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint32 a, gtUint128 b, uint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint32 b, uint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint32 a, gtUint128 b, uint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint32 b, uint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint32 a, gtUint128 b, uint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint32 b, uint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint32 a, gtUint128 b, uint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint32 b, uint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint32 a, gtUint128 b, uint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint32 b, uint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint64 a, gtUint128 b, uint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint64 b, uint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint64 a, gtUint128 b, uint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint64 b, uint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint64 a, gtUint128 b, uint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint64 b, uint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint64 a, gtUint128 b, uint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint64 b, uint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint64 a, gtUint128 b, uint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }

    function transferWithAllowance(gtUint128 a, gtUint64 b, uint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
            (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
                TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
            return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
        }


    // =========== Transfer with allowance functions for public amount ==============

    function transferWithAllowance(gtUint256 a, gtUint256 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint8.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint8.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint16.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint16.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint32.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint32.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint64.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint64.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, uint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, uint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, uint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, uint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, uint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint128.unwrap(a), gtUint256.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, uint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.LHS_PUBLIC), gtUint256.unwrap(a), gtUint128.unwrap(b), uint256(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    

 // ================= Cast operation =================
 // =========== 8 - 16 bit operations ==============

    function add(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function add(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedAdd(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedAdd(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint8 a, gtUint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint16 a, gtUint8 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function sub(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function sub(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedSub(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedSub(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint8 a, gtUint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint16 a, gtUint8 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function mul(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function mul(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedMul(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedMul(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b));

        return checkRes16(gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint8 a, gtUint16 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint16 a, gtUint8 b) internal returns (gtBool, gtUint16) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint16.wrap(res));
    }

    function div(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function div(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function rem(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function rem(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function and(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function and(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function or(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function or(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
          return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function xor(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function xor(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function eq(gtUint8 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function eq(gtUint16 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function ne(gtUint8 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function ne(gtUint16 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function ge(gtUint8 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function ge(gtUint16 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function gt(gtUint8 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function gt(gtUint16 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function le(gtUint8 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

     function le(gtUint16 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function lt(gtUint8 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function lt(gtUint16 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function min(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function min(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function max(gtUint8 a, gtUint16 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function max(gtUint16 a, gtUint8 b) internal returns (gtUint16) {
        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function mux(gtBool bit, gtUint8 a, gtUint16 b) internal returns (gtUint16){
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint8.unwrap(a), gtUint16.unwrap(b)));
    }

    function mux(gtBool bit, gtUint16 a, gtUint8 b) internal returns (gtUint16){
         return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint16.unwrap(a), gtUint8.unwrap(b)));
    }

    function transfer(gtUint8 a, gtUint16 b, gtUint16 amount) internal returns (gtUint16, gtUint16, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint8 b, gtUint16 amount) internal returns (gtUint16, gtUint16, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint16 b, gtUint8 amount) internal returns (gtUint16, gtUint16, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint8 b, gtUint8 amount) internal returns (gtUint16, gtUint16, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint16 b, gtUint8 amount) internal returns (gtUint16, gtUint16, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint16 a, gtUint8 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint16 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint8 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint16 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint16 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint16 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    // Allowance with 16 bit

    function transferWithAllowance(gtUint16 a, gtUint8 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint16 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET),
            gtUint8.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint8 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint16 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET),
            gtUint8.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint16 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint16, gtUint16, gtBool, gtUint16){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint16.wrap(new_a), gtUint16.wrap(new_b), gtBool.wrap(res), gtUint16.wrap(new_allowance));
    }



    // =========== 8- 32 bit operations ==============

    function add(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function add(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedAdd(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedAdd(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint8 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint32 a, gtUint8 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function sub(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function sub(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedSub(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedSub(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint8 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint32 a, gtUint8 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function mul(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function mul(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedMul(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedMul(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint8 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint32 a, gtUint8 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function div(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function div(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function rem(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function rem(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function and(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function and(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function or(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function or(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function xor(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function xor(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function eq(gtUint8 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function eq(gtUint32 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function ne(gtUint8 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function ne(gtUint32 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function ge(gtUint8 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function ge(gtUint32 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function gt(gtUint8 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function gt(gtUint32 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function le(gtUint8 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function le(gtUint32 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function lt(gtUint8 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function lt(gtUint32 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function min(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function min(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function max(gtUint8 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

     function max(gtUint32 a, gtUint8 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function mux(gtBool bit, gtUint8 a, gtUint32 b) internal returns (gtUint32){
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint8.unwrap(a), gtUint32.unwrap(b)));
    }

    function mux(gtBool bit, gtUint32 a, gtUint8 b) internal returns (gtUint32){
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint32.unwrap(a), gtUint8.unwrap(b)));
    }

    function transfer(gtUint8 a, gtUint32 b, gtUint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T,  MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint8 b, gtUint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T,  MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint32 b, gtUint8 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T,  MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint8 b, gtUint8 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T,  MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint32 b, gtUint16 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T,  MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint8 b, gtUint16 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T,  MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint32 b, gtUint8 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T,  MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint32 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }
    
    function transferWithAllowance(gtUint8 a, gtUint32 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }
    
    function transferWithAllowance(gtUint8 a, gtUint32 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    // Allowance with 16 bit
    function transferWithAllowance(gtUint32 a, gtUint8 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint32 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }
    
    function transferWithAllowance(gtUint8 a, gtUint32 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }
    
    function transferWithAllowance(gtUint8 a, gtUint32 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    // Allowance with 32 bit
    function transferWithAllowance(gtUint32 a, gtUint8 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint32 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }
    
    function transferWithAllowance(gtUint8 a, gtUint32 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint8 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }
    
    function transferWithAllowance(gtUint8 a, gtUint32 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    // =========== 16 - 32 bit operations ==============

    function add(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function add(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedAdd(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedAdd(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint16 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint32 a, gtUint16 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function sub(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function sub(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedSub(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedSub(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint16 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint32 a, gtUint16 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function mul(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function mul(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedMul(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedMul(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b));

        return checkRes32(gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint16 a, gtUint32 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint32 a, gtUint16 b) internal returns (gtBool, gtUint32) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint32.wrap(res));
    }

    function div(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function div(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function rem(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function rem(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function and(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function and(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function or(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function or(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
          return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function xor(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function xor(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function eq(gtUint16 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function eq(gtUint32 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function ne(gtUint16 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function ne(gtUint32 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function ge(gtUint16 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function ge(gtUint32 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function gt(gtUint16 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function gt(gtUint32 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function le(gtUint16 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function le(gtUint32 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function lt(gtUint16 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function lt(gtUint32 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function min(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function min(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function max(gtUint16 a, gtUint32 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

     function max(gtUint32 a, gtUint16 b) internal returns (gtUint32) {
        return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function mux(gtBool bit, gtUint16 a, gtUint32 b) internal returns (gtUint32){
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint16.unwrap(a), gtUint32.unwrap(b)));
    }

    function mux(gtBool bit, gtUint32 a, gtUint16 b) internal returns (gtUint32){
         return gtUint32.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint32.unwrap(a), gtUint16.unwrap(b)));
    }

    function transfer(gtUint16 a, gtUint32 b, gtUint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint16 b, gtUint32 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint32 b, gtUint8 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint16 b, gtUint8 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint32 b, gtUint16 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint16 b, gtUint16 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint32 b, gtUint16 amount) internal returns (gtUint32, gtUint32, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T,  MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    // Allowance with 16 bit
    function transferWithAllowance(gtUint16 a, gtUint32 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    // Allowance with 32 bit
    function transferWithAllowance(gtUint16 a, gtUint32 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint32 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint16 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint32 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint32, gtUint32, gtBool, gtUint32){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint32.wrap(new_a), gtUint32.wrap(new_b), gtBool.wrap(res), gtUint32.wrap(new_allowance));
    }



// =========== 8 - 64 bit operations ==============
    
    function add(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function add(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedAdd(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAdd(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint8 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint64 a, gtUint8 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function sub(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function sub(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedSub(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSub(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint8 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint64 a, gtUint8 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function mul(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function mul(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedMul(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMul(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint8 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint64 a, gtUint8 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function div(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function div(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function rem(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function rem(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function and(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function and(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function or(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function or(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function xor(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function xor(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function eq(gtUint8 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function eq(gtUint64 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function ne(gtUint8 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function ne(gtUint64 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function ge(gtUint8 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function ge(gtUint64 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function gt(gtUint8 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }
    
    function gt(gtUint64 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function le(gtUint8 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }
    
    function le(gtUint64 a, gtUint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function lt(gtUint8 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function lt(gtUint64 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function min(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function min(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function max(gtUint8 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

     function max(gtUint64 a, gtUint8 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function mux(gtBool bit, gtUint8 a, gtUint64 b) internal returns (gtUint64){
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint8.unwrap(a), gtUint64.unwrap(b)));
    }

    function mux(gtBool bit, gtUint64 a, gtUint8 b) internal returns (gtUint64){
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint64.unwrap(a), gtUint8.unwrap(b)));
    }

    function transfer(gtUint8 a, gtUint64 b, gtUint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint8 b, gtUint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint64 b, gtUint8 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint8 b, gtUint8 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint64 b, gtUint16 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint8 b, gtUint16 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

     function transfer(gtUint8 a, gtUint64 b, gtUint32 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint8 b, gtUint32 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint64 b, gtUint8 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 16 bit 
    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 32 bit
    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 64 bit
    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint64 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint8.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint8 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }
    

    // =========== 16 - 64 bit operations ==============
    
    function add(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function add(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedAdd(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAdd(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint16 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint64 a, gtUint16 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function sub(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function sub(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedSub(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSub(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint16 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint64 a, gtUint16 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function mul(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function mul(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedMul(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMul(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint16 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint64 a, gtUint16 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function div(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function div(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function rem(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function rem(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function and(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function and(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function or(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function or(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function xor(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function xor(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function eq(gtUint16 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function eq(gtUint64 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function ne(gtUint16 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function ne(gtUint64 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function ge(gtUint16 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function ge(gtUint64 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function gt(gtUint16 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }
    
    function gt(gtUint64 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function le(gtUint16 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }
    
    function le(gtUint64 a, gtUint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function lt(gtUint16 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function lt(gtUint64 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function min(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function min(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function max(gtUint16 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

     function max(gtUint64 a, gtUint16 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function mux(gtBool bit, gtUint16 a, gtUint64 b) internal returns (gtUint64){
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint16.unwrap(a), gtUint64.unwrap(b)));
    }

    function mux(gtBool bit, gtUint64 a, gtUint16 b) internal returns (gtUint64){
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint64.unwrap(a), gtUint16.unwrap(b)));
    }

    function transfer(gtUint16 a, gtUint64 b, gtUint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint16 b, gtUint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint64 b, gtUint8 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint16 b, gtUint8 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint64 b, gtUint16 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint16 b, gtUint16 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint64 b, gtUint32 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint16 b, gtUint32 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint64 b, gtUint16 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 16 bit
    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 32 bit
    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 64 bit
    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint64 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint16.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint16 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }



     // =========== 32 - 64 bit operations ==============
    
    function add(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function add(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function checkedAdd(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAdd(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint32 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint64 a, gtUint32 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function sub(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function sub(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function checkedSub(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSub(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint32 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint64 a, gtUint32 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function mul(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function mul(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function checkedMul(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMul(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b));

        return checkRes64(gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint32 a, gtUint64 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint64 a, gtUint32 b) internal returns (gtBool, gtUint64) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint64.wrap(res));
    }

    function div(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function div(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function rem(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function rem(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function and(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function and(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function or(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function or(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
          return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function xor(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function xor(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function eq(gtUint32 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function eq(gtUint64 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function ne(gtUint32 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function ne(gtUint64 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function ge(gtUint32 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function ge(gtUint64 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function gt(gtUint32 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }
    
    function gt(gtUint64 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function le(gtUint32 a, gtUint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }
    
    function le(gtUint64 a, gtUint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function lt(gtUint32 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function lt(gtUint64 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function min(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function min(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function max(gtUint32 a, gtUint64 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

     function max(gtUint64 a, gtUint32 b) internal returns (gtUint64) {
        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function mux(gtBool bit, gtUint32 a, gtUint64 b) internal returns (gtUint64){
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint32.unwrap(a), gtUint64.unwrap(b)));
    }

    function mux(gtBool bit, gtUint64 a, gtUint32 b) internal returns (gtUint64){
         return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint64.unwrap(a), gtUint32.unwrap(b)));
    }

    function transfer(gtUint32 a, gtUint64 b, gtUint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint32 b, gtUint64 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint64 b, gtUint8 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint32 b, gtUint8 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint64 b, gtUint16 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint32 b, gtUint16 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint64 b, gtUint32 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint32 b, gtUint32 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint64 b, gtUint32 amount) internal returns (gtUint64, gtUint64, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 16 bit
    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 32 bit
    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    // Allowance with 64 bit
    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint64 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint32.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint32 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint64 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint64, gtUint64, gtBool, gtUint64){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), 
            gtUint64.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint64.wrap(new_a), gtUint64.wrap(new_b), gtBool.wrap(res), gtUint64.wrap(new_allowance));
    }


    // =========== Cast 128 bit operations ==============

    // 128- 8 bit cast

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transfer(gtUint128 a, gtUint128 b, gtUint8 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transfer(gtUint128 a, gtUint128 b, gtUint16 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transfer(gtUint128 a, gtUint128 b, gtUint32 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transfer(gtUint128 a, gtUint128 b, gtUint64 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint128 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function add(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function add(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function sub(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function sub(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function mul(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function mul(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function div(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function div(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function rem(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function rem(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function and(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function and(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function or(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function or(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function xor(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function xor(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function eq(gtUint8 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function eq(gtUint128 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function ne(gtUint8 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function ne(gtUint128 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function ge(gtUint8 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function ge(gtUint128 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function gt(gtUint8 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function gt(gtUint128 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function le(gtUint8 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function le(gtUint128 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function lt(gtUint8 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function lt(gtUint128 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function min(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function min(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function max(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function max(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedAdd(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAdd(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint8 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint128 a, gtUint8 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSub(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSub(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint8 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint128 a, gtUint8 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMul(gtUint8 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMul(gtUint128 a, gtUint8 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint8 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint128 a, gtUint8 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function mux(gtBool bit, gtUint8 a, gtUint128 b) internal returns (gtUint128){
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint8.unwrap(a), gtUint128.unwrap(b)));
    }

    function mux(gtBool bit, gtUint128 a, gtUint8 b) internal returns (gtUint128){
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint128.unwrap(a), gtUint8.unwrap(b)));
    }

    function transfer(gtUint8 a, gtUint128 b, gtUint8 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint8 b, gtUint8 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint128 b, gtUint16 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint8 b, gtUint16 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint128 b, gtUint32 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint8 b, gtUint32 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint128 b, gtUint64 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint8 b, gtUint64 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint128 b, gtUint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint8 b, gtUint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint8 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint128 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }



    function add(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function add(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function sub(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function sub(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function mul(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function mul(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function div(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function div(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function rem(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function rem(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function and(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function and(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function or(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function or(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function xor(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function xor(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function eq(gtUint16 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function eq(gtUint128 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function ne(gtUint16 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function ne(gtUint128 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function ge(gtUint16 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function ge(gtUint128 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function gt(gtUint16 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function gt(gtUint128 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function le(gtUint16 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function le(gtUint128 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function lt(gtUint16 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function lt(gtUint128 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function min(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function min(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function max(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function max(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedAdd(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAdd(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint16 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint128 a, gtUint16 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSub(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSub(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint16 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint128 a, gtUint16 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMul(gtUint16 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMul(gtUint128 a, gtUint16 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint16 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint128 a, gtUint16 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function mux(gtBool bit, gtUint16 a, gtUint128 b) internal returns (gtUint128){
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint16.unwrap(a), gtUint128.unwrap(b)));
    }

    function mux(gtBool bit, gtUint128 a, gtUint16 b) internal returns (gtUint128){
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint128.unwrap(a), gtUint16.unwrap(b)));
    }

    function transfer(gtUint16 a, gtUint128 b, gtUint8 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint16 b, gtUint8 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint128 b, gtUint16 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint16 b, gtUint16 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint128 b, gtUint32 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint16 b, gtUint32 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint128 b, gtUint64 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint16 b, gtUint64 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint128 b, gtUint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint16 b, gtUint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint16 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint128 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }



    function add(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function add(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function sub(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function sub(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function mul(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function mul(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function div(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function div(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function rem(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function rem(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function and(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function and(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function or(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function or(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function xor(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function xor(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function eq(gtUint32 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function eq(gtUint128 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function ne(gtUint32 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function ne(gtUint128 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function ge(gtUint32 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function ge(gtUint128 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function gt(gtUint32 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function gt(gtUint128 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function le(gtUint32 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function le(gtUint128 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function lt(gtUint32 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function lt(gtUint128 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function min(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function min(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function max(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function max(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function checkedAdd(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAdd(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint32 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint128 a, gtUint32 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSub(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSub(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint32 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint128 a, gtUint32 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMul(gtUint32 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMul(gtUint128 a, gtUint32 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint32 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint128 a, gtUint32 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function mux(gtBool bit, gtUint32 a, gtUint128 b) internal returns (gtUint128){
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint32.unwrap(a), gtUint128.unwrap(b)));
    }

    function mux(gtBool bit, gtUint128 a, gtUint32 b) internal returns (gtUint128){
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint128.unwrap(a), gtUint32.unwrap(b)));
    }

    function transfer(gtUint32 a, gtUint128 b, gtUint8 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint32 b, gtUint8 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint128 b, gtUint16 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint32 b, gtUint16 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint128 b, gtUint32 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint32 b, gtUint32 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint128 b, gtUint64 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint32 b, gtUint64 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint128 b, gtUint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint32 b, gtUint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint32 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint128 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }



    function add(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function add(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function sub(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function sub(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function mul(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function mul(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function div(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function div(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function rem(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function rem(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function and(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function and(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function or(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function or(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function xor(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function xor(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function eq(gtUint64 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function eq(gtUint128 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function ne(gtUint64 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function ne(gtUint128 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function ge(gtUint64 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function ge(gtUint128 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function gt(gtUint64 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function gt(gtUint128 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function le(gtUint64 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function le(gtUint128 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function lt(gtUint64 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function lt(gtUint128 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function min(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function min(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function max(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function max(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function checkedAdd(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAdd(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint64 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint128 a, gtUint64 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSub(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSub(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint64 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint128 a, gtUint64 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMul(gtUint64 a, gtUint128 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMul(gtUint128 a, gtUint64 b) internal returns (gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b));

        return checkRes128(gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint64 a, gtUint128 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint128 a, gtUint64 b) internal returns (gtBool, gtUint128) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint128.wrap(res));
    }

    function mux(gtBool bit, gtUint64 a, gtUint128 b) internal returns (gtUint128){
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint64.unwrap(a), gtUint128.unwrap(b)));
    }

    function mux(gtBool bit, gtUint128 a, gtUint64 b) internal returns (gtUint128){
         return gtUint128.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint128.unwrap(a), gtUint64.unwrap(b)));
    }

    function transfer(gtUint64 a, gtUint128 b, gtUint8 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint64 b, gtUint8 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint128 b, gtUint16 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint64 b, gtUint16 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint128 b, gtUint32 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint64 b, gtUint32 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint128 b, gtUint64 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint64 b, gtUint64 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint128 b, gtUint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint64 b, gtUint128 amount) internal returns (gtUint128, gtUint128, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint64 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint128 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint128, gtUint128, gtBool, gtUint128){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint128.wrap(new_a), gtUint128.wrap(new_b), gtBool.wrap(res), gtUint128.wrap(new_allowance));
    }


    // =========== Cast 256 bit operations ==============

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transfer(gtUint256 a, gtUint256 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transfer(gtUint256 a, gtUint256 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transfer(gtUint256 a, gtUint256 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transfer(gtUint256 a, gtUint256 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transfer(gtUint256 a, gtUint256 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint256 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function add(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function add(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function sub(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function sub(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function mul(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function mul(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function div(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function div(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function rem(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function rem(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function and(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function and(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function or(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function or(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function xor(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function xor(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function eq(gtUint8 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function eq(gtUint256 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function ne(gtUint8 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function ne(gtUint256 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function ge(gtUint8 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function ge(gtUint256 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function gt(gtUint8 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function gt(gtUint256 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function le(gtUint8 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function le(gtUint256 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function lt(gtUint8 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function lt(gtUint256 a, gtUint8 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function min(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function min(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function max(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function max(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function checkedAdd(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAdd(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint8 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint256 a, gtUint8 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint8 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint256 a, gtUint8 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint8 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint256 a, gtUint8 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint8 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint256 a, gtUint8 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function mux(gtBool bit, gtUint8 a, gtUint256 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint8.unwrap(a), gtUint256.unwrap(b)));
    }

    function mux(gtBool bit, gtUint256 a, gtUint8 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint256.unwrap(a), gtUint8.unwrap(b)));
    }

    function transfer(gtUint8 a, gtUint256 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint8 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint256 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint8 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint256 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint8 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint256 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint8 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint256 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint8 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint8 a, gtUint256 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint8 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint8 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint8.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint8 a, gtUint256 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint8.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }



    function add(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function add(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function sub(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function sub(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function mul(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function mul(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function div(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function div(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function rem(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function rem(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function and(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function and(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function or(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function or(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function xor(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function xor(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function eq(gtUint16 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function eq(gtUint256 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function ne(gtUint16 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function ne(gtUint256 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function ge(gtUint16 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function ge(gtUint256 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function gt(gtUint16 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function gt(gtUint256 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function le(gtUint16 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function le(gtUint256 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function lt(gtUint16 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function lt(gtUint256 a, gtUint16 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function min(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function min(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function max(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function max(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function checkedAdd(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAdd(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint16 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint256 a, gtUint16 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint16 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint256 a, gtUint16 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint16 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint256 a, gtUint16 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint16 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint256 a, gtUint16 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function mux(gtBool bit, gtUint16 a, gtUint256 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint16.unwrap(a), gtUint256.unwrap(b)));
    }

    function mux(gtBool bit, gtUint256 a, gtUint16 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint256.unwrap(a), gtUint16.unwrap(b)));
    }

    function transfer(gtUint16 a, gtUint256 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint16 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint256 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint16 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint256 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint16 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint256 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint16 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint256 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint16 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint16 a, gtUint256 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint16 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint16 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint16.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint16 a, gtUint256 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint16.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }



    function add(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function add(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function sub(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function sub(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function mul(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function mul(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function div(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function div(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function rem(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function rem(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function and(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function and(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function or(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function or(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function xor(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function xor(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function eq(gtUint32 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function eq(gtUint256 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function ne(gtUint32 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function ne(gtUint256 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function ge(gtUint32 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function ge(gtUint256 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function gt(gtUint32 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function gt(gtUint256 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function le(gtUint32 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function le(gtUint256 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function lt(gtUint32 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function lt(gtUint256 a, gtUint32 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function min(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function min(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function max(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function max(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function checkedAdd(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAdd(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint32 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint256 a, gtUint32 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint32 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint256 a, gtUint32 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint32 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint256 a, gtUint32 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint32 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint256 a, gtUint32 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function mux(gtBool bit, gtUint32 a, gtUint256 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint32.unwrap(a), gtUint256.unwrap(b)));
    }

    function mux(gtBool bit, gtUint256 a, gtUint32 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint256.unwrap(a), gtUint32.unwrap(b)));
    }

    function transfer(gtUint32 a, gtUint256 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint32 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint256 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint32 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint256 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint32 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint256 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint32 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint256 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint32 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint32 a, gtUint256 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint32 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint32 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint32.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint32 a, gtUint256 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint32.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }



    function add(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function add(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function sub(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function sub(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function mul(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function mul(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function div(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function div(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function rem(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function rem(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function and(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function and(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function or(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function or(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function xor(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function xor(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function eq(gtUint64 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function eq(gtUint256 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function ne(gtUint64 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function ne(gtUint256 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function ge(gtUint64 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function ge(gtUint256 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function gt(gtUint64 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function gt(gtUint256 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function le(gtUint64 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function le(gtUint256 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function lt(gtUint64 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function lt(gtUint256 a, gtUint64 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function min(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function min(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function max(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function max(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function checkedAdd(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAdd(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint64 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint256 a, gtUint64 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint64 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint256 a, gtUint64 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint64 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint256 a, gtUint64 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint64 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint256 a, gtUint64 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function mux(gtBool bit, gtUint64 a, gtUint256 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint64.unwrap(a), gtUint256.unwrap(b)));
    }

    function mux(gtBool bit, gtUint256 a, gtUint64 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint256.unwrap(a), gtUint64.unwrap(b)));
    }

    function transfer(gtUint64 a, gtUint256 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint64 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint256 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint64 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint256 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint64 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint256 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint64 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint256 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint64 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint64 a, gtUint256 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint64 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint64 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint64.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint64 a, gtUint256 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint64.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }



    function add(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function add(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Add(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function sub(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function sub(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Sub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function mul(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function mul(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function div(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function div(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Div(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function rem(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function rem(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Rem(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function and(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function and(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            And(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function or(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function or(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Or(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function xor(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function xor(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Xor(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function eq(gtUint128 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function eq(gtUint256 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Eq(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function ne(gtUint128 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function ne(gtUint256 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ne(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function ge(gtUint128 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function ge(gtUint256 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Ge(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function gt(gtUint128 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function gt(gtUint256 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Gt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function le(gtUint128 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function le(gtUint256 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Le(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function lt(gtUint128 a, gtUint256 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function lt(gtUint256 a, gtUint128 b) internal returns (gtBool) {
        return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Lt(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function min(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function min(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Min(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function max(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function max(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Max(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function checkedAdd(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAdd(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint128 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedAddWithOverflowBit(gtUint256 a, gtUint128 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedAdd(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSub(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint128 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedSubWithOverflowBit(gtUint256 a, gtUint128 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedSub(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint128 a, gtUint256 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMul(gtUint256 a, gtUint128 b) internal returns (gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b));

        return checkRes256(gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint128 a, gtUint256 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function checkedMulWithOverflowBit(gtUint256 a, gtUint128 b) internal returns (gtBool, gtUint256) {
        (uint256 bit, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            CheckedMul(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b));

        return (gtBool.wrap(bit), gtUint256.wrap(res));
    }

    function mux(gtBool bit, gtUint128 a, gtUint256 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint128.unwrap(a), gtUint256.unwrap(b)));
    }

    function mux(gtBool bit, gtUint256 a, gtUint128 b) internal returns (gtUint256){
         return gtUint256.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
            Mux(combineEnumsToBytes3(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtBool.unwrap(bit), gtUint256.unwrap(a), gtUint128.unwrap(b)));
    }

    function transfer(gtUint128 a, gtUint256 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint128 b, gtUint8 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint256 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint128 b, gtUint16 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint256 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint128 b, gtUint32 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint256 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint128 b, gtUint64 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint256 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint128 b, gtUint128 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint128 a, gtUint256 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transfer(gtUint256 a, gtUint128 b, gtUint256 amount) internal returns (gtUint256, gtUint256, gtBool){
        (uint256 new_a, uint256 new_b, uint256 res) = ExtendedOperations(address(MPC_PRECOMPILE)).
            Transfer(combineEnumsToBytes4(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint256.unwrap(amount));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint8 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint16 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint32 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint64 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint128 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint256 amount, gtUint8 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint8.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint8 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint16 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint32 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint64 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint128 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint256 amount, gtUint16 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint16.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint8 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint16 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint32 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint64 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint128 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint256 amount, gtUint32 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint32.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint8 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint16 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint32 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint64 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint128 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint256 amount, gtUint64 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint64.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint8 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint16 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint32 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint64 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint128 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint256 amount, gtUint128 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint128.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint8 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint8.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint16 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint16.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint32 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint32.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint64 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint64.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint128 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint128.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint256 a, gtUint128 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint256.unwrap(a), gtUint128.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }

    function transferWithAllowance(gtUint128 a, gtUint256 b, gtUint256 amount, gtUint256 allowance) internal returns (gtUint256, gtUint256, gtBool, gtUint256){
        (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance) = ExtendedOperations(address(MPC_PRECOMPILE)).
            TransferWithAllowance(combineEnumsToBytes5(MPC_TYPE.SUINT128_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, MPC_TYPE.SUINT256_T, ARGS.BOTH_SECRET), gtUint128.unwrap(a), gtUint256.unwrap(b), gtUint256.unwrap(amount), gtUint256.unwrap(allowance));
        return (gtUint256.wrap(new_a), gtUint256.wrap(new_b), gtBool.wrap(res), gtUint256.wrap(new_allowance));
    }


}