@pendle/core-v2 2.15.1 → 2.16.0

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol/ScaleDataHelperEthereum.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../../../build-info/9185209af761a5bdb8b0d916c080079d.json"
-}

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol/ScaleDataHelperEthereum.json

@@ -1,10 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "ScaleDataHelperEthereum",
-  "sourceName": "contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol",
-  "abi": [],
-  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122042f2c9ed6176c32d6ee2a036d64e87452b186ef711dcdaaf7babaeeb5e21038964736f6c63430008110033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122042f2c9ed6176c32d6ee2a036d64e87452b186ef711dcdaaf7babaeeb5e21038964736f6c63430008110033",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

package/contracts/router/swap-aggregator/1inch/I1inchAggregationRouterV5.sol

@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity 0.8.17;
-
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-interface I1inchAggregationRouterV5 {
-    struct SwapDescription {
-        IERC20 srcToken;
-        IERC20 dstToken;
-        address payable srcReceiver;
-        address payable dstReceiver;
-        uint256 amount;
-        uint256 minReturnAmount;
-        uint256 flags;
-    }
-
-    function uniswapV3SwapTo(
-        address payable recipient,
-        uint256 amount,
-        uint256 minReturn,
-        uint256[] calldata pools
-    ) external payable returns (uint256 returnAmount);
-
-    function swap(
-        address executor,
-        SwapDescription calldata desc,
-        bytes calldata permit,
-        bytes calldata data
-    ) external payable returns (uint256 returnAmount, uint256 spentAmount);
-
-    function unoswapTo(
-        address payable recipient,
-        address srcToken,
-        uint256 amount,
-        uint256 minReturn,
-        uint256[] calldata pools
-    ) external payable returns (uint256 returnAmount);
-}

package/contracts/router/swap-aggregator/1inch/OneInchAggregationRouterHelper.sol

@@ -1,68 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity 0.8.17;
-
-import "./I1inchAggregationRouterV5.sol";
-import "../../../core/libraries/Errors.sol";
-
-abstract contract OneInchAggregationRouterHelper {
-    function _rescaleMinAmount(
-        uint256 minAmount,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (uint256) {
-        return (minAmount * newAmount) / oldAmount;
-    }
-
-    function _get1inchScaledInputData(
-        bytes calldata rawCallData,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
-        bytes4 selector = bytes4(rawCallData[:4]);
-        bytes memory args = rawCallData[4:];
-
-        if (selector == I1inchAggregationRouterV5.uniswapV3SwapTo.selector) {
-            (
-                address payable recipient,
-                uint256 amount,
-                uint256 minReturn,
-                uint256[] memory pools
-            ) = abi.decode(args, (address, uint256, uint256, uint256[]));
-
-            minReturn = _rescaleMinAmount(minReturn, amount, newAmount);
-            amount = newAmount;
-            return abi.encodeWithSelector(selector, recipient, amount, minReturn, pools);
-        }
-
-        if (selector == I1inchAggregationRouterV5.swap.selector) {
-            (
-                address executor,
-                I1inchAggregationRouterV5.SwapDescription memory desc,
-                bytes memory permit,
-                bytes memory data
-            ) = abi.decode(
-                    args,
-                    (address, I1inchAggregationRouterV5.SwapDescription, bytes, bytes)
-                );
-
-            desc.minReturnAmount = _rescaleMinAmount(desc.minReturnAmount, desc.amount, newAmount);
-            desc.amount = newAmount;
-            return abi.encodeWithSelector(selector, executor, desc, permit, data);
-        }
-
-        if (selector == I1inchAggregationRouterV5.unoswapTo.selector) {
-            (
-                address payable recipient,
-                address srcToken,
-                uint256 amount,
-                uint256 minReturn,
-                uint256[] memory pools
-            ) = abi.decode(args, (address, address, uint256, uint256, uint256[]));
-
-            minReturn = _rescaleMinAmount(minReturn, amount, newAmount);
-            amount = newAmount;
-            return abi.encodeWithSelector(selector, recipient, srcToken, amount, minReturn, pools);
-        }
-        revert Errors.UnsupportedSelector(1, selector);
-    }
-}

package/contracts/router/swap-aggregator/PendleSwapArbitrum.sol

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "@openzeppelin/contracts/utils/Address.sol";
-import "../../core/libraries/TokenHelper.sol";
-import "../../core/libraries/Errors.sol";
-import "./IPSwapAggregator.sol";
-import "./1inch/OneInchAggregationRouterHelper.sol";
-import "./kyberswap/arbitrum/KyberHelperArbitrum.sol";
-
-contract PendleSwapArbitrum is
-    IPSwapAggregator,
-    TokenHelper,
-    KyberHelperArbitrum,
-    OneInchAggregationRouterHelper
-{
-    using Address for address;
-
-    function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
-        _safeApproveInf(tokenIn, data.extRouter);
-        data.extRouter.functionCallWithValue(
-            data.needScale
-                ? _getScaledInputData(data.swapType, data.extCalldata, amountIn)
-                : data.extCalldata,
-            tokenIn == NATIVE ? amountIn : 0
-        );
-    }
-
-    function _getScaledInputData(
-        SwapType swapType,
-        bytes calldata rawCallData,
-        uint256 amountIn
-    ) internal pure returns (bytes memory scaledCallData) {
-        if (swapType == SwapType.KYBERSWAP) {
-            scaledCallData = _getKyberScaledInputData(rawCallData, amountIn);
-        } else if (swapType == SwapType.ONE_INCH) {
-            scaledCallData = _get1inchScaledInputData(rawCallData, amountIn);
-        } else {
-            assert(false);
-        }
-    }
-
-    receive() external payable {}
-
-}

package/contracts/router/swap-aggregator/kyberswap/arbitrum/IExecutorHelper2.sol

@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
-
-interface IExecutorHelper2 {
-    function executeKyberLimitOrder(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-}

package/contracts/router/swap-aggregator/kyberswap/arbitrum/KyberHelperArbitrum.sol

@@ -1,200 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
-
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import { IExecutorHelper1 } from "./IExecutorHelper1.sol";
-import { IExecutorHelper2 } from "./IExecutorHelper2.sol";
-import { IMetaAggregationRouterV2 } from "./IMetaAggregationRouterV2.sol";
-import { ScaleDataHelperArbitrum } from "./ScaleDataHelperArbitrum.sol";
-
-abstract contract KyberHelperArbitrum {
-    uint256 private constant _PARTIAL_FILL = 0x01;
-    uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
-    uint256 private constant _SHOULD_CLAIM = 0x04;
-    uint256 private constant _BURN_FROM_MSG_SENDER = 0x08;
-    uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
-    uint256 private constant _SIMPLE_SWAP = 0x20;
-
-    struct Swap {
-        bytes data;
-        bytes4 selector;
-    }
-
-    struct SimpleSwapData {
-        address[] firstPools;
-        uint256[] firstSwapAmounts;
-        bytes[] swapDatas;
-        uint256 deadline;
-        bytes destTokenFeeData;
-    }
-
-    struct SwapExecutorDescription {
-        Swap[][] swapSequences;
-        address tokenIn;
-        address tokenOut;
-        uint256 minTotalAmountOut;
-        address to;
-        uint256 deadline;
-        bytes destTokenFeeData;
-    }
-
-    function _getKyberScaledInputData(
-        bytes calldata kybercall,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
-        bytes4 selector = bytes4(kybercall[:4]);
-
-        if (selector == IMetaAggregationRouterV2.swap.selector) {
-            IMetaAggregationRouterV2.SwapExecutionParams memory params = abi.decode(
-                kybercall[4:],
-                (IMetaAggregationRouterV2.SwapExecutionParams)
-            );
-
-            (params.desc, params.targetData) = _getScaledInputDataV2(
-                params.desc,
-                params.targetData,
-                newAmount,
-                _flagsChecked(params.desc.flags, _SIMPLE_SWAP)
-            );
-            return abi.encodeWithSelector(selector, params);
-        }
-
-        if (selector == IMetaAggregationRouterV2.swapSimpleMode.selector) {
-            (
-                address callTarget,
-                IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
-                bytes memory targetData,
-                bytes memory clientData
-            ) = abi.decode(
-                    kybercall[4:],
-                    (address, IMetaAggregationRouterV2.SwapDescriptionV2, bytes, bytes)
-                );
-
-            (desc, targetData) = _getScaledInputDataV2(desc, targetData, newAmount, true);
-            return abi.encodeWithSelector(selector, callTarget, desc, targetData, clientData);
-        }
-
-        revert("InputScalingHelper: Invalid selector");
-    }
-
-    function _getScaledInputDataV2(
-        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
-        bytes memory executorData,
-        uint256 newAmount,
-        bool isSimpleMode
-    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 memory, bytes memory) {
-        uint256 oldAmount = desc.amount;
-        if (oldAmount == newAmount) {
-            return (desc, executorData);
-        }
-
-        // simple mode swap
-        if (isSimpleMode) {
-            return (
-                _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
-                _scaledSimpleSwapData(executorData, oldAmount, newAmount)
-            );
-        }
-
-        //normal mode swap
-        return (
-            _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
-            _scaledExecutorCallBytesData(executorData, oldAmount, newAmount)
-        );
-    }
-
-    function _scaledSimpleSwapData(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
-        SimpleSwapData memory swapData = abi.decode(data, (SimpleSwapData));
-        uint256 numberSeq = swapData.firstPools.length;
-        uint256 newTotalSwapAmount;
-        for (uint256 i = 0; i < numberSeq; i++) {
-            if (i == numberSeq - 1) {
-                swapData.firstSwapAmounts[i] = newAmount - newTotalSwapAmount;
-            } else {
-                swapData.firstSwapAmounts[i] =
-                    (swapData.firstSwapAmounts[i] * newAmount) /
-                    oldAmount;
-            }
-            newTotalSwapAmount += swapData.firstSwapAmounts[i];
-        }
-        return abi.encode(swapData);
-    }
-
-    function _scaledExecutorCallBytesData(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
-        SwapExecutorDescription memory executorDesc = abi.decode(data, (SwapExecutorDescription));
-        executorDesc.minTotalAmountOut = (executorDesc.minTotalAmountOut * newAmount) / oldAmount;
-        for (uint256 i = 0; i < executorDesc.swapSequences.length; i++) {
-            Swap memory swap = executorDesc.swapSequences[i][0];
-            bytes4 selector = swap.selector;
-
-            if (selector == IExecutorHelper1.executeUniSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newUniSwap(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeStableSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newStableSwap(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeCurveSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newCurveSwap(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeKyberDMMSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newKyberDMM(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeUniV3ProMMSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newUniV3ProMM(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeRfqSwap.selector) {
-                revert("InputScalingHelper: Can not scale RFQ swap");
-            } else if (selector == IExecutorHelper1.executeBalV2Swap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newBalancerV2(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeDODOSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newDODO(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeVelodromeSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newVelodrome(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeGMXSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newGMX(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeSynthetixSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newSynthetix(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper1.executeHashflowSwap.selector) {
-                revert("InputScalingHelper: Can not scale RFQ swap");
-            } else if (selector == IExecutorHelper1.executeCamelotSwap.selector) {
-                swap.data = ScaleDataHelperArbitrum.newCamelot(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelper2.executeKyberLimitOrder.selector) {
-                revert("InputScalingHelper: Can not scale RFQ swap");
-            } else revert("AggregationExecutor: Dex type not supported");
-        }
-        return abi.encode(executorDesc);
-    }
-
-    function _scaledSwapDescriptionV2(
-        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 memory) {
-        uint256 oldMinReturnAmount = desc.minReturnAmount;
-        desc.minReturnAmount = (desc.minReturnAmount * newAmount) / oldAmount;
-        //newMinReturnAmount should no be 0 if oldMinReturnAmount > 0
-        if (oldMinReturnAmount > 0 && desc.minReturnAmount == 0) desc.minReturnAmount = 1;
-        desc.amount = newAmount;
-        if (desc.srcReceivers.length == 0) {
-            return desc;
-        }
-
-        uint256 newTotal;
-        for (uint256 i = 0; i < desc.srcReceivers.length; i++) {
-            if (i == desc.srcReceivers.length - 1) {
-                desc.srcAmounts[i] = newAmount - newTotal;
-            } else {
-                desc.srcAmounts[i] = (desc.srcAmounts[i] * newAmount) / oldAmount;
-            }
-            newTotal += desc.srcAmounts[i];
-        }
-        return desc;
-    }
-
-    function _flagsChecked(uint256 number, uint256 flag) internal pure returns (bool) {
-        return number & flag != 0;
-    }
-}

package/contracts/router/swap-aggregator/kyberswap/ethereum/IAggregationExecutor.sol

@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity >=0.6.12;
-
-interface IAggregationExecutor {
-    function callBytes(bytes calldata data) external payable; // 0xd9c45357
-
-    // callbytes per swap sequence
-    function swapSingleSequence(bytes calldata data) external;
-
-    function finalTransactionProcessing(
-        address tokenIn,
-        address tokenOut,
-        address to,
-        bytes calldata destTokenFeeData
-    ) external;
-}

package/contracts/router/swap-aggregator/kyberswap/ethereum/IExecutorHelperEthereum1.sol

@@ -1,191 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
-
-import "./IHashflow.sol";
-
-interface IExecutorHelperEthereum1 {
-    struct UniSwap {
-        address pool;
-        address tokenIn;
-        address tokenOut;
-        address recipient;
-        uint256 collectAmount; // amount that should be transferred to the pool
-        uint256 limitReturnAmount;
-        uint32 swapFee;
-        uint32 feePrecision;
-        uint32 tokenWeightInput;
-    }
-
-    struct StableSwap {
-        address pool;
-        address tokenFrom;
-        address tokenTo;
-        uint8 tokenIndexFrom;
-        uint8 tokenIndexTo;
-        uint256 dx;
-        uint256 minDy;
-        uint256 poolLength;
-        address poolLp;
-        bool isSaddle; // true: saddle, false: stable
-    }
-
-    struct CurveSwap {
-        address pool;
-        address tokenFrom;
-        address tokenTo;
-        int128 tokenIndexFrom;
-        int128 tokenIndexTo;
-        uint256 dx;
-        uint256 minDy;
-        bool usePoolUnderlying;
-        bool useTriCrypto;
-    }
-
-    struct UniSwapV3ProMM {
-        address recipient;
-        address pool;
-        address tokenIn;
-        address tokenOut;
-        uint256 swapAmount;
-        uint256 limitReturnAmount;
-        uint160 sqrtPriceLimitX96;
-        bool isUniV3; // true = UniV3, false = ProMM
-    }
-
-    struct BalancerV2 {
-        address vault;
-        bytes32 poolId;
-        address assetIn;
-        address assetOut;
-        uint256 amount;
-        uint256 limit;
-    }
-
-    struct KyberRFQ {
-        address rfq;
-        bytes order;
-        bytes signature;
-        uint256 amount;
-        address payable target;
-    }
-
-    struct DODO {
-        address recipient;
-        address pool;
-        address tokenFrom;
-        address tokenTo;
-        uint256 amount;
-        uint256 minReceiveQuote;
-        address sellHelper;
-        bool isSellBase;
-        bool isVersion2;
-    }
-
-    struct Synthetix {
-        address synthetixProxy;
-        address tokenIn;
-        address tokenOut;
-        bytes32 sourceCurrencyKey;
-        uint256 sourceAmount;
-        bytes32 destinationCurrencyKey;
-        uint256 minAmount;
-        bool useAtomicExchange;
-    }
-
-    struct PSM {
-        address router;
-        address tokenIn;
-        address tokenOut;
-        uint256 amountIn;
-        address recipient;
-    }
-
-    struct Hashflow {
-        address router;
-        IHashflow.Quote quote;
-    }
-
-    struct WSTETH {
-        address pool;
-        uint256 amount;
-        bool isWrapping;
-    }
-
-    function executeUniSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeStableSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeCurveSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeKyberDMMSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeUniV3ProMMSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeRfqSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeBalV2Swap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeDODOSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeWrappedstETHSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeSynthetixSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executePSMSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeHashflowSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-
-    function executeFraxSwap(
-        uint256 index,
-        bytes memory data,
-        uint256 previousAmountOut
-    ) external payable returns (uint256);
-}

package/contracts/router/swap-aggregator/kyberswap/ethereum/IHashflow.sol

@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity 0.8.17;
-
-interface IHashflow {
-    enum RFQType {
-        TAKER,
-        MAKER
-    }
-
-    struct Quote {
-        RFQType rfqType;
-        address pool;
-        address eoa;
-        address trader;
-        address effectiveTrader;
-        address baseToken;
-        address quoteToken;
-        uint256 effectiveBaseTokenAmount;
-        uint256 maxBaseTokenAmount;
-        uint256 maxQuoteTokenAmount;
-        uint256 fees;
-        uint256 quoteExpiry;
-        uint256 nonce;
-        bytes32 txid;
-        bytes signedQuote;
-    }
-
-    function tradeSingleHop(Quote memory quote) external payable;
-}

package/contracts/router/swap-aggregator/kyberswap/ethereum/IMetaAggregationRouterV2.sol

@@ -1,41 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
-
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "./IAggregationExecutor.sol";
-
-interface IMetaAggregationRouterV2 {
-    struct SwapDescriptionV2 {
-        IERC20 srcToken;
-        IERC20 dstToken;
-        address[] srcReceivers; // transfer src token to these addresses, default
-        uint256[] srcAmounts;
-        address[] feeReceivers;
-        uint256[] feeAmounts;
-        address dstReceiver;
-        uint256 amount;
-        uint256 minReturnAmount;
-        uint256 flags;
-        bytes permit;
-    }
-
-    /// @dev  use for swapGeneric and swap to avoid stack too deep
-    struct SwapExecutionParams {
-        address callTarget; // call this address
-        address approveTarget; // approve this address if _APPROVE_FUND set
-        bytes targetData;
-        SwapDescriptionV2 desc;
-        bytes clientData;
-    }
-
-    function swap(
-        SwapExecutionParams calldata execution
-    ) external payable returns (uint256, uint256);
-
-    function swapSimpleMode(
-        IAggregationExecutor caller,
-        SwapDescriptionV2 memory desc,
-        bytes calldata executorData,
-        bytes calldata clientData
-    ) external returns (uint256, uint256);
-}