Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

import "./ICToken.sol";
import "./IYearn.sol";
import "./ILendingPoolV2.sol";
import "./IBasket.sol";
import "./IATokenV2.sol";
import "./ICurveZap.sol";
import "./ICurve.sol";

import "./ABDKMath64x64.sol";

import "./ERC20.sol";
import "./IERC20.sol";
import "./SafeERC20.sol";
import "./SafeMath.sol";
import "./Ownable.sol";

import "./console.sol";

contract BMIZapper is Ownable {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    using ABDKMath64x64 for int128;
    using ABDKMath64x64 for uint256;

    // Auxillery
    address constant AAVE_LENDING_POOL_V2 = 0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9;

    // Tokens

    // BMI
    address public BMI;

    // Bare
    address constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
    address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
    address constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
    address constant TUSD = 0x0000000000085d4780B73119b644AE5ecd22b376;
    address constant SUSD = 0x57Ab1ec28D129707052df4dF418D58a2D46d5f51;
    address constant BUSD = 0x4Fabb145d64652a948d72533023f6E7A623C7C53;
    address constant USDP = 0x1456688345527bE1f37E9e627DA0837D6f08C925;
    address constant FRAX = 0x853d955aCEf822Db058eb8505911ED77F175b99e;
    address constant ALUSD = 0xBC6DA0FE9aD5f3b0d58160288917AA56653660E9;
    address constant LUSD = 0x5f98805A4E8be255a32880FDeC7F6728C6568bA0;
    address constant USDN = 0x674C6Ad92Fd080e4004b2312b45f796a192D27a0;

    // Yearn
    address constant yDAI = 0x19D3364A399d251E894aC732651be8B0E4e85001;
    address constant yUSDC = 0x5f18C75AbDAe578b483E5F43f12a39cF75b973a9;
    address constant yUSDT = 0x7Da96a3891Add058AdA2E826306D812C638D87a7;
    address constant yTUSD = 0x37d19d1c4E1fa9DC47bD1eA12f742a0887eDa74a;
    address constant ySUSD = 0xa5cA62D95D24A4a350983D5B8ac4EB8638887396;

    // Yearn CRV
    address constant yCRV = 0x4B5BfD52124784745c1071dcB244C6688d2533d3; // Y Pool
    address constant ycrvSUSD = 0x5a770DbD3Ee6bAF2802D29a901Ef11501C44797A;
    address constant ycrvYBUSD = 0x8ee57c05741aA9DB947A744E713C15d4d19D8822;
    address constant ycrvBUSD = 0x6Ede7F19df5df6EF23bD5B9CeDb651580Bdf56Ca;
    address constant ycrvUSDP = 0xC4dAf3b5e2A9e93861c3FBDd25f1e943B8D87417;
    address constant ycrvFRAX = 0xB4AdA607B9d6b2c9Ee07A275e9616B84AC560139;
    address constant ycrvALUSD = 0xA74d4B67b3368E83797a35382AFB776bAAE4F5C8;
    address constant ycrvLUSD = 0x5fA5B62c8AF877CB37031e0a3B2f34A78e3C56A6;
    address constant ycrvUSDN = 0x3B96d491f067912D18563d56858Ba7d6EC67a6fa;
    address constant ycrvIB = 0x27b7b1ad7288079A66d12350c828D3C00A6F07d7;
    address constant ycrvThree = 0x84E13785B5a27879921D6F685f041421C7F482dA;
    address constant ycrvDUSD = 0x30FCf7c6cDfC46eC237783D94Fc78553E79d4E9C;
    address constant ycrvMUSD = 0x8cc94ccd0f3841a468184aCA3Cc478D2148E1757;
    address constant ycrvUST = 0x1C6a9783F812b3Af3aBbf7de64c3cD7CC7D1af44;

    // Aave
    address constant aDAI = 0x028171bCA77440897B824Ca71D1c56caC55b68A3;
    address constant aUSDC = 0xBcca60bB61934080951369a648Fb03DF4F96263C;
    address constant aUSDT = 0x3Ed3B47Dd13EC9a98b44e6204A523E766B225811;
    address constant aTUSD = 0x101cc05f4A51C0319f570d5E146a8C625198e636;
    address constant aSUSD = 0x6C5024Cd4F8A59110119C56f8933403A539555EB;

    // Compound
    address constant cDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
    address constant cUSDC = 0x39AA39c021dfbaE8faC545936693aC917d5E7563;
    address constant cUSDT = 0xf650C3d88D12dB855b8bf7D11Be6C55A4e07dCC9;
    address constant cTUSD = 0x12392F67bdf24faE0AF363c24aC620a2f67DAd86;

    // Curve
    address constant crvY = 0xdF5e0e81Dff6FAF3A7e52BA697820c5e32D806A8;
    address constant crvYPool = 0x45F783CCE6B7FF23B2ab2D70e416cdb7D6055f51;
    address constant crvYZap = 0xbBC81d23Ea2c3ec7e56D39296F0cbB648873a5d3;

    address constant crvSUSD = 0xC25a3A3b969415c80451098fa907EC722572917F;
    address constant crvSUSDPool = 0xA5407eAE9Ba41422680e2e00537571bcC53efBfD;
    address constant crvSUSDZap = 0xFCBa3E75865d2d561BE8D220616520c171F12851;

    address constant crvYBUSD = 0x3B3Ac5386837Dc563660FB6a0937DFAa5924333B;
    address constant crvYBUSDPool = 0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27;
    address constant crvYBUSDZap = 0xb6c057591E073249F2D9D88Ba59a46CFC9B59EdB;

    address constant crvThree = 0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490;
    address constant crvThreePool = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7;

    address constant crvUSDP = 0x7Eb40E450b9655f4B3cC4259BCC731c63ff55ae6;
    address constant crvUSDPPool = 0x42d7025938bEc20B69cBae5A77421082407f053A;
    address constant crvUSDPZap = 0x3c8cAee4E09296800f8D29A68Fa3837e2dae4940;

    address constant crvDUSD = 0x3a664Ab939FD8482048609f652f9a0B0677337B9;
    address constant crvDUSDPool = 0x8038C01A0390a8c547446a0b2c18fc9aEFEcc10c;
    address constant crvDUSDZap = 0x61E10659fe3aa93d036d099405224E4Ac24996d0;

    address constant crvMUSD = 0x1AEf73d49Dedc4b1778d0706583995958Dc862e6;
    address constant crvMUSDPool = 0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6;
    address constant crvMUSDZap = 0x803A2B40c5a9BB2B86DD630B274Fa2A9202874C2;

    address constant crvUST = 0x94e131324b6054c0D789b190b2dAC504e4361b53;
    address constant crvUSTPool = 0x890f4e345B1dAED0367A877a1612f86A1f86985f;
    address constant crvUSTZap = 0xB0a0716841F2Fc03fbA72A891B8Bb13584F52F2d;

    address constant crvUSDN = 0x4f3E8F405CF5aFC05D68142F3783bDfE13811522;
    address constant crvUSDNPool = 0x0f9cb53Ebe405d49A0bbdBD291A65Ff571bC83e1;
    address constant crvUSDNZap = 0x094d12e5b541784701FD8d65F11fc0598FBC6332;

    address constant crvIB = 0x5282a4eF67D9C33135340fB3289cc1711c13638C;
    address constant crvIBPool = 0x2dded6Da1BF5DBdF597C45fcFaa3194e53EcfeAF;

    address constant crvBUSD = 0x4807862AA8b2bF68830e4C8dc86D0e9A998e085a;
    address constant crvFRAX = 0xd632f22692FaC7611d2AA1C0D552930D43CAEd3B;
    address constant crvALUSD = 0x43b4FdFD4Ff969587185cDB6f0BD875c5Fc83f8c;
    address constant crvLUSD = 0xEd279fDD11cA84bEef15AF5D39BB4d4bEE23F0cA;

    address constant crvMetaZapper = 0xA79828DF1850E8a3A3064576f380D90aECDD3359;

    // **** Constructor ****

    constructor(address _bmi) {
        BMI = _bmi;
    }

    function recoverERC20(address _token) public onlyOwner {
        IERC20(_token).safeTransfer(msg.sender, IERC20(_token).balanceOf(address(this)));
    }

    function recoverERC20s(address[] memory _tokens) public onlyOwner {
        for (uint256 i = 0; i < _tokens.length; i++) {
            IERC20(_tokens[i]).safeTransfer(msg.sender, IERC20(_tokens[i]).balanceOf(address(this)));
        }
    }

    // **** View only functions **** //

    // Estimates USDC equilavent for yearn crv and crv pools
    function calcUSDCEquilavent(address _from, uint256 _amount) public view returns (uint256) {
        if (_isYearnCRV(_from)) {
            _amount = _amount.mul(IYearn(_from).pricePerShare()).div(1e18);
            _from = IYearn(_from).token();
        }

        if (_from == crvY || _from == crvSUSD || _from == crvThree || _from == crvYBUSD) {
            address zap = crvYZap;

            if (_from == crvSUSD) {
                zap = crvSUSDZap;
            } else if (_from == crvThree) {
                zap = crvThreePool;
            } else if (_from == crvYBUSD) {
                zap = crvYBUSDZap;
            }

            return ICurveZapSimple(zap).calc_withdraw_one_coin(_amount, 1);
        } else if (_from == crvUSDN || _from == crvUSDP || _from == crvDUSD || _from == crvMUSD || _from == crvUST) {
            address zap = crvUSDNZap;

            if (_from == crvUSDP) {
                zap = crvUSDPZap;
            } else if (_from == crvDUSD) {
                zap = crvDUSDZap;
            } else if (_from == crvMUSD) {
                zap = crvMUSDZap;
            } else if (_from == crvUST) {
                zap = crvUSTZap;
            }

            return ICurveZapSimple(zap).calc_withdraw_one_coin(_amount, 2);
        } else if (_from == crvIB) {
            return ICurveZapSimple(crvIBPool).calc_withdraw_one_coin(_amount, 1, true);
        } else {
            // Meta pools, USDC is 2nd index
            return ICurveZapSimple(crvMetaZapper).calc_withdraw_one_coin(_from, _amount, 2);
        }
    }

    function getUnderlyingAmount(address _derivative, uint256 _amount) public view returns (address, uint256) {
        if (_isAave(_derivative)) {
            return (IATokenV2(_derivative).UNDERLYING_ASSET_ADDRESS(), _amount);
        }

        if (_isCompound(_derivative)) {
            uint256 rate = ICToken(_derivative).exchangeRateStored();
            address underlying = ICToken(_derivative).underlying();
            uint256 underlyingDecimals = ERC20(underlying).decimals();
            uint256 mantissa = 18 + underlyingDecimals - 8;
            uint256 oneCTokenInUnderlying = rate.mul(1e18).div(10**mantissa);
            return (underlying, _amount.mul(oneCTokenInUnderlying).div(1e8));
        }

        // YearnCRV just or CRV return USDC
        if (_isCRV(_derivative) || _isYearnCRV(_derivative)) {
            return (USDC, calcUSDCEquilavent(_derivative, _amount));
        }

        if (_isYearn(_derivative)) {
            _amount = _amount.mul(IYearn(_derivative).pricePerShare()).div(1e18);

            if (_derivative == yDAI) {
                return (DAI, _amount);
            }

            if (_derivative == yUSDC) {
                return (USDC, _amount);
            }

            if (_derivative == yUSDT) {
                return (USDT, _amount);
            }

            if (_derivative == yTUSD) {
                return (TUSD, _amount);
            }

            if (_derivative == ySUSD) {
                return (SUSD, _amount);
            }
        }

        return (_derivative, _amount);
    }

    // **** Stateful functions ****

    function zapToBMI(
        address _from,
        uint256 _amount,
        address _fromUnderlying,
        uint256 _fromUnderlyingAmount,
        uint256 _minBMIRecv,
        address[] memory _bmiConstituents,
        uint256[] memory _bmiConstituentsWeightings,
        address _aggregator,
        bytes memory _aggregatorData,
        bool refundDust
    ) public returns (uint256) {
        uint256 sum = 0;
        for (uint256 i = 0; i < _bmiConstituentsWeightings.length; i++) {
            sum = sum.add(_bmiConstituentsWeightings[i]);
        }

        // Sum should be between 0.999 and 1.000
        assert(sum <= 1e18);
        assert(sum >= 999e15);

        // Transfer to contract
        IERC20(_from).safeTransferFrom(msg.sender, address(this), _amount);

        // Primitive
        if (_isBare(_from)) {
            _primitiveToBMI(_from, _amount, _bmiConstituents, _bmiConstituentsWeightings, _aggregator, _aggregatorData);
        }
        // Yearn (primitive)
        else if (_isYearn(_from)) {
            IYearn(_from).withdraw();
            _primitiveToBMI(
                _fromUnderlying,
                _fromUnderlyingAmount,
                _bmiConstituents,
                _bmiConstituentsWeightings,
                _aggregator,
                _aggregatorData
            );
        }
        // Yearn (primitive)
        else if (_isYearnCRV(_from)) {
            IYearn(_from).withdraw();
            address crvToken = IYearn(_from).token();
            _crvToPrimitive(crvToken, IERC20(crvToken).balanceOf(address(this)));
            _primitiveToBMI(
                USDC,
                IERC20(USDC).balanceOf(address(this)),
                _bmiConstituents,
                _bmiConstituentsWeightings,
                address(0),
                ""
            );
        }
        // Compound
        else if (_isCompound(_from)) {
            require(ICToken(_from).redeem(_amount) == 0, "!ctoken-redeem");
            _primitiveToBMI(
                _fromUnderlying,
                _fromUnderlyingAmount,
                _bmiConstituents,
                _bmiConstituentsWeightings,
                _aggregator,
                _aggregatorData
            );
        }
        // Aave
        else if (_isAave(_from)) {
            IERC20(_from).safeApprove(AAVE_LENDING_POOL_V2, 0);
            IERC20(_from).safeApprove(AAVE_LENDING_POOL_V2, _amount);
            ILendingPoolV2(AAVE_LENDING_POOL_V2).withdraw(_fromUnderlying, type(uint256).max, address(this));

            _primitiveToBMI(
                _fromUnderlying,
                _fromUnderlyingAmount,
                _bmiConstituents,
                _bmiConstituentsWeightings,
                _aggregator,
                _aggregatorData
            );
        }
        // Curve
        else {
            _crvToPrimitive(_from, _amount);
            _primitiveToBMI(
                USDC,
                IERC20(USDC).balanceOf(address(this)),
                _bmiConstituents,
                _bmiConstituentsWeightings,
                address(0),
                ""
            );
        }

        // Checks
        uint256 _bmiBal = IERC20(BMI).balanceOf(address(this));
        require(_bmiBal >= _minBMIRecv, "!min-mint");
        IERC20(BMI).safeTransfer(msg.sender, _bmiBal);

        // Convert back dust to USDC and refund remaining USDC to usd
        if (refundDust) {
            for (uint256 i = 0; i < _bmiConstituents.length; i++) {
                _fromBMIConstituentToUSDC(_bmiConstituents[i], IERC20(_bmiConstituents[i]).balanceOf(address(this)));
            }
            IERC20(USDC).safeTransfer(msg.sender, IERC20(USDC).balanceOf(address(this)));
        }

        return _bmiBal;
    }

    // **** Internal helpers ****

    function _crvToPrimitive(address _from, uint256 _amount) internal {
        // Remove via zap to USDC
        if (_from == crvY || _from == crvSUSD || _from == crvYBUSD) {
            address zap = crvYZap;

            if (_from == crvSUSD) {
                zap = crvSUSDZap;
            } else if (_from == crvYBUSD) {
                zap = crvYBUSDZap;
            }

            IERC20(_from).safeApprove(zap, 0);
            IERC20(_from).safeApprove(zap, _amount);
            ICurveZapSimple(zap).remove_liquidity_one_coin(_amount, 1, 0, false);
        } else if (_from == crvUSDP || _from == crvUSDN || _from == crvDUSD || _from == crvMUSD || _from == crvUST) {
            address zap = crvUSDNZap;

            if (_from == crvUSDP) {
                zap = crvUSDPZap;
            } else if (_from == crvDUSD) {
                zap = crvDUSDZap;
            } else if (_from == crvMUSD) {
                zap = crvMUSDZap;
            } else if (_from == crvUST) {
                zap = crvUSTZap;
            }

            IERC20(_from).safeApprove(zap, 0);
            IERC20(_from).safeApprove(zap, _amount);
            ICurveZapSimple(zap).remove_liquidity_one_coin(_amount, 2, 0);
        } else if (_from == crvIB) {
            IERC20(_from).safeApprove(crvIBPool, 0);
            IERC20(_from).safeApprove(crvIBPool, _amount);
            ICurveZapSimple(crvIBPool).remove_liquidity_one_coin(_amount, 1, 0, true);
        } else if (_from == crvThree) {
            address zap = crvThreePool;

            IERC20(_from).safeApprove(zap, 0);
            IERC20(_from).safeApprove(zap, _amount);
            ICurveZapSimple(zap).remove_liquidity_one_coin(_amount, 1, 0);
        } else {
            // Meta pools, USDC is 2nd index
            IERC20(_from).safeApprove(crvMetaZapper, 0);
            IERC20(_from).safeApprove(crvMetaZapper, _amount);
            ICurveZapSimple(crvMetaZapper).remove_liquidity_one_coin(_from, _amount, 2, 0, address(this));
        }
    }

    function _primitiveToBMI(
        address _token,
        uint256 _amount,
        address[] memory _bmiConstituents,
        uint256[] memory _bmiConstituentsWeightings,
        address _aggregator,
        bytes memory _aggregatorData
    ) internal {
        // Offset, DAI = 0, USDC = 1, USDT = 2
        uint256 offset = 0;

        // Primitive to USDC (if not already USDC)
        if (_token != DAI && _token != USDC && _token != USDT) {
            IERC20(_token).safeApprove(_aggregator, 0);
            IERC20(_token).safeApprove(_aggregator, _amount);

            (bool success, ) = _aggregator.call(_aggregatorData);
            require(success, "!swap");

            // Always goes to USDC
            // If we swapping
            _token = USDC;
        }

        if (_token == USDC) {
            offset = 1;
        } else if (_token == USDT) {
            offset = 2;
        }

        // Amount to mint
        uint256 amountToMint;
        uint256 bmiSupply = IERC20(BMI).totalSupply();

        uint256 tokenBal = IERC20(_token).balanceOf(address(this));
        uint256 tokenAmount;
        for (uint256 i = 0; i < _bmiConstituents.length; i++) {
            // Weighting of the token for BMI constituient
            tokenAmount = tokenBal.mul(_bmiConstituentsWeightings[i]).div(1e18);
            _toBMIConstituent(_token, _bmiConstituents[i], tokenAmount, offset);

            // Get amount to Mint
            amountToMint = _approveBMIAndGetMintableAmount(bmiSupply, _bmiConstituents[i], amountToMint);
        }

        // Mint BASK
        IBasket(BMI).mint(amountToMint);
    }

    function _approveBMIAndGetMintableAmount(
        uint256 _bmiTotalSupply,
        address _bmiConstituient,
        uint256 _curMintAmount
    ) internal returns (uint256) {
        uint256 bal = IERC20(_bmiConstituient).balanceOf(address(this));
        uint256 bmiBal = IERC20(_bmiConstituient).balanceOf(BMI);

        IERC20(_bmiConstituient).safeApprove(BMI, 0);
        IERC20(_bmiConstituient).safeApprove(BMI, bal);

        // Calculate how much BMI we can mint at max
        // Formula: min(e for e in bmiSupply * tokenWeHave[e] / tokenInBMI[e])
        if (_curMintAmount == 0) {
            return _bmiTotalSupply.mul(bal).div(bmiBal);
        }

        uint256 temp = _bmiTotalSupply.mul(bal).div(bmiBal);
        if (temp < _curMintAmount) {
            return temp;
        }

        return _curMintAmount;
    }

    function _toBMIConstituent(
        address _fromToken,
        address _toToken,
        uint256 _amount,
        uint256 _curveOffset
    ) internal {
        uint256 bal;
        uint256[4] memory depositAmounts4 = [uint256(0), uint256(0), uint256(0), uint256(0)];

        if (_toToken == ySUSD) {
            IERC20(_fromToken).safeApprove(crvSUSDPool, 0);
            IERC20(_fromToken).safeApprove(crvSUSDPool, _amount);

            ICurvePool(crvSUSDPool).exchange(int128(_curveOffset), 3, _amount, 0);

            bal = IERC20(SUSD).balanceOf(address(this));
            IERC20(SUSD).safeApprove(ySUSD, 0);
            IERC20(SUSD).safeApprove(ySUSD, bal);
        }
        // Gen 1 pools
        else if (
            _toToken == yCRV ||
            _toToken == ycrvSUSD ||
            _toToken == ycrvYBUSD ||
            _toToken == ycrvUSDN ||
            _toToken == ycrvUSDP ||
            _toToken == ycrvDUSD ||
            _toToken == ycrvMUSD ||
            _toToken == ycrvUST
        ) {
            address crvToken = IYearn(_toToken).token();

            address zap = crvYZap;
            if (_toToken == ycrvSUSD) {
                zap = crvSUSDZap;
            } else if (_toToken == ycrvYBUSD) {
                zap = crvYBUSDZap;
            } else if (_toToken == ycrvUSDN) {
                zap = crvUSDNZap;
                _curveOffset += 1;
            } else if (_toToken == ycrvUSDP) {
                zap = crvUSDPZap;
                _curveOffset += 1;
            } else if (_toToken == ycrvDUSD) {
                zap = crvDUSDZap;
                _curveOffset += 1;
            } else if (_toToken == ycrvMUSD) {
                zap = crvMUSDZap;
                _curveOffset += 1;
            } else if (_toToken == ycrvUST) {
                zap = crvUSTZap;
                _curveOffset += 1;
            }

            depositAmounts4[_curveOffset] = _amount;
            IERC20(_fromToken).safeApprove(zap, 0);
            IERC20(_fromToken).safeApprove(zap, _amount);
            ICurveZapSimple(zap).add_liquidity(depositAmounts4, 0);

            bal = IERC20(crvToken).balanceOf(address(this));
            IERC20(crvToken).safeApprove(_toToken, 0);
            IERC20(crvToken).safeApprove(_toToken, bal);
        } else if (_toToken == ycrvThree || _toToken == ycrvIB) {
            address crvToken = IYearn(_toToken).token();

            uint256[3] memory depositAmounts3 = [uint256(0), uint256(0), uint256(0)];
            depositAmounts3[_curveOffset] = _amount;

            address zap = crvThreePool;
            if (_toToken == ycrvIB) {
                zap = crvIBPool;
            }

            IERC20(_fromToken).safeApprove(zap, 0);
            IERC20(_fromToken).safeApprove(zap, _amount);

            if (_toToken == ycrvThree) {
                ICurveZapSimple(zap).add_liquidity(depositAmounts3, 0);
            } else {
                ICurveZapSimple(zap).add_liquidity(depositAmounts3, 0, true);
            }

            bal = IERC20(crvToken).balanceOf(address(this));
            IERC20(crvToken).safeApprove(_toToken, 0);
            IERC20(crvToken).safeApprove(_toToken, bal);
        }
        // Meta pools
        else if (_toToken == ycrvBUSD || _toToken == ycrvFRAX || _toToken == ycrvALUSD || _toToken == ycrvLUSD) {
            // CRV Token = CRV Pool
            address crvToken = IYearn(_toToken).token();

            depositAmounts4[_curveOffset + 1] = _amount;
            IERC20(_fromToken).safeApprove(crvMetaZapper, 0);
            IERC20(_fromToken).safeApprove(crvMetaZapper, _amount);

            ICurveZapSimple(crvMetaZapper).add_liquidity(crvToken, depositAmounts4, 0);

            bal = IERC20(crvToken).balanceOf(address(this));
            IERC20(crvToken).safeApprove(_toToken, 0);
            IERC20(crvToken).safeApprove(_toToken, bal);
        }

        IYearn(_toToken).deposit();
    }

    function _fromBMIConstituentToUSDC(address _fromToken, uint256 _amount) internal {
        if (_isYearnCRV(_fromToken)) {
            _crvToPrimitive(IYearn(_fromToken).token(), IYearn(_fromToken).withdraw(_amount));
        }
    }

    function _isBare(address _token) internal pure returns (bool) {
        return (_token == DAI ||
            _token == USDC ||
            _token == USDT ||
            _token == TUSD ||
            _token == SUSD ||
            _token == BUSD ||
            _token == USDP ||
            _token == FRAX ||
            _token == ALUSD ||
            _token == LUSD ||
            _token == USDN);
    }

    function _isYearn(address _token) internal pure returns (bool) {
        return (_token == yDAI || _token == yUSDC || _token == yUSDT || _token == yTUSD || _token == ySUSD);
    }

    function _isYearnCRV(address _token) internal pure returns (bool) {
        return (_token == yCRV ||
            _token == ycrvSUSD ||
            _token == ycrvYBUSD ||
            _token == ycrvBUSD ||
            _token == ycrvUSDP ||
            _token == ycrvFRAX ||
            _token == ycrvALUSD ||
            _token == ycrvLUSD ||
            _token == ycrvUSDN ||
            _token == ycrvThree ||
            _token == ycrvIB ||
            _token == ycrvMUSD ||
            _token == ycrvUST ||
            _token == ycrvDUSD);
    }

    function _isCRV(address _token) internal pure returns (bool) {
        return (_token == crvY ||
            _token == crvSUSD ||
            _token == crvYBUSD ||
            _token == crvBUSD ||
            _token == crvUSDP ||
            _token == crvFRAX ||
            _token == crvALUSD ||
            _token == crvLUSD ||
            _token == crvThree ||
            _token == crvUSDN ||
            _token == crvDUSD ||
            _token == crvMUSD ||
            _token == crvUST ||
            _token == crvIB);
    }

    function _isCompound(address _token) internal pure returns (bool) {
        return (_token == cDAI || _token == cUSDC || _token == cUSDT || _token == cTUSD);
    }

    function _isAave(address _token) internal pure returns (bool) {
        return (_token == aDAI || _token == aUSDC || _token == aUSDT || _token == aTUSD || _token == aSUSD);
    }
}

// SPDX-License-Identifier: BSD-4-Clause
/*
 * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
 * Author: Mikhail Vladimirov <[email protected]>
 */
pragma solidity ^0.7.0;

/**
 * Smart contract library of mathematical functions operating with signed
 * 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is
 * basically a simple fraction whose numerator is signed 128-bit integer and
 * denominator is 2^64.  As long as denominator is always the same, there is no
 * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
 * represented by int128 type holding only the numerator.
 */
library ABDKMath64x64 {
  /*
   * Minimum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;

  /*
   * Maximum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

  /**
   * Convert signed 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromInt (int256 x) internal pure returns (int128) {
    require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
    return int128 (x << 64);
  }

  /**
   * Convert signed 64.64 fixed point number into signed 64-bit integer number
   * rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64-bit integer number
   */
  function toInt (int128 x) internal pure returns (int64) {
    return int64 (x >> 64);
  }

  /**
   * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromUInt (uint256 x) internal pure returns (int128) {
    require (x <= 0x7FFFFFFFFFFFFFFF);
    return int128 (x << 64);
  }

  /**
   * Convert signed 64.64 fixed point number into unsigned 64-bit integer
   * number rounding down.  Revert on underflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return unsigned 64-bit integer number
   */
  function toUInt (int128 x) internal pure returns (uint64) {
    require (x >= 0);
    return uint64 (x >> 64);
  }

  /**
   * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
   * number rounding down.  Revert on overflow.
   *
   * @param x signed 128.128-bin fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function from128x128 (int256 x) internal pure returns (int128) {
    int256 result = x >> 64;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Convert signed 64.64 fixed point number into signed 128.128 fixed point
   * number.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 128.128 fixed point number
   */
  function to128x128 (int128 x) internal pure returns (int256) {
    return int256 (x) << 64;
  }

  /**
   * Calculate x + y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function add (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) + y;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x - y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sub (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) - y;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x * y rounding down.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function mul (int128 x, int128 y) internal pure returns (int128) {
    int256 result = int256(x) * y >> 64;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
   * number and y is signed 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y signed 256-bit integer number
   * @return signed 256-bit integer number
   */
  function muli (int128 x, int256 y) internal pure returns (int256) {
    if (x == MIN_64x64) {
      require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF &&
        y <= 0x1000000000000000000000000000000000000000000000000);
      return -y << 63;
    } else {
      bool negativeResult = false;
      if (x < 0) {
        x = -x;
        negativeResult = true;
      }
      if (y < 0) {
        y = -y; // We rely on overflow behavior here
        negativeResult = !negativeResult;
      }
      uint256 absoluteResult = mulu (x, uint256 (y));
      if (negativeResult) {
        require (absoluteResult <=
          0x8000000000000000000000000000000000000000000000000000000000000000);
        return -int256 (absoluteResult); // We rely on overflow behavior here
      } else {
        require (absoluteResult <=
          0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
        return int256 (absoluteResult);
      }
    }
  }

  /**
   * Calculate x * y rounding down, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y unsigned 256-bit integer number
   * @return unsigned 256-bit integer number
   */
  function mulu (int128 x, uint256 y) internal pure returns (uint256) {
    if (y == 0) return 0;

    require (x >= 0);

    uint256 lo = (uint256 (x) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
    uint256 hi = uint256 (x) * (y >> 128);

    require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    hi <<= 64;

    require (hi <=
      0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo);
    return hi + lo;
  }

  /**
   * Calculate x / y rounding towards zero.  Revert on overflow or when y is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function div (int128 x, int128 y) internal pure returns (int128) {
    require (y != 0);
    int256 result = (int256 (x) << 64) / y;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are signed 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x signed 256-bit integer number
   * @param y signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divi (int256 x, int256 y) internal pure returns (int128) {
    require (y != 0);

    bool negativeResult = false;
    if (x < 0) {
      x = -x; // We rely on overflow behavior here
      negativeResult = true;
    }
    if (y < 0) {
      y = -y; // We rely on overflow behavior here
      negativeResult = !negativeResult;
    }
    uint128 absoluteResult = divuu (uint256 (x), uint256 (y));
    if (negativeResult) {
      require (absoluteResult <= 0x80000000000000000000000000000000);
      return -int128 (absoluteResult); // We rely on overflow behavior here
    } else {
      require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return int128 (absoluteResult); // We rely on overflow behavior here
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divu (uint256 x, uint256 y) internal pure returns (int128) {
    require (y != 0);
    uint128 result = divuu (x, y);
    require (result <= uint128 (MAX_64x64));
    return int128 (result);
  }

  /**
   * Calculate -x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function neg (int128 x) internal pure returns (int128) {
    require (x != MIN_64x64);
    return -x;
  }

  /**
   * Calculate |x|.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function abs (int128 x) internal pure returns (int128) {
    require (x != MIN_64x64);
    return x < 0 ? -x : x;
  }

  /**
   * Calculate 1 / x rounding towards zero.  Revert on overflow or when x is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function inv (int128 x) internal pure returns (int128) {
    require (x != 0);
    int256 result = int256 (0x100000000000000000000000000000000) / x;
    require (result >= MIN_64x64 && result <= MAX_64x64);
    return int128 (result);
  }

  /**
   * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function avg (int128 x, int128 y) internal pure returns (int128) {
    return int128 ((int256 (x) + int256 (y)) >> 1);
  }

  /**
   * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
   * Revert on overflow or in case x * y is negative.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function gavg (int128 x, int128 y) internal pure returns (int128) {
    int256 m = int256 (x) * int256 (y);
    require (m >= 0);
    require (m <
        0x4000000000000000000000000000000000000000000000000000000000000000);
    return int128 (sqrtu (uint256 (m)));
  }

  /**
   * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y uint256 value
   * @return signed 64.64-bit fixed point number
   */
  function pow (int128 x, uint256 y) internal pure returns (int128) {
    uint256 absoluteResult;
    bool negativeResult = false;
    if (x >= 0) {
      absoluteResult = powu (uint256 (x) << 63, y);
    } else {
      // We rely on overflow behavior here
      absoluteResult = powu (uint256 (uint128 (-x)) << 63, y);
      negativeResult = y & 1 > 0;
    }

    absoluteResult >>= 63;

    if (negativeResult) {
      require (absoluteResult <= 0x80000000000000000000000000000000);
      return -int128 (absoluteResult); // We rely on overflow behavior here
    } else {
      require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return int128 (absoluteResult); // We rely on overflow behavior here
    }
  }

  /**
   * Calculate sqrt (x) rounding down.  Revert if x < 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sqrt (int128 x) internal pure returns (int128) {
    require (x >= 0);
    return int128 (sqrtu (uint256 (x) << 64));
  }

  /**
   * Calculate binary logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function log_2 (int128 x) internal pure returns (int128) {
    require (x > 0);

    int256 msb = 0;
    int256 xc = x;
    if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
    if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
    if (xc >= 0x10000) { xc >>= 16; msb += 16; }
    if (xc >= 0x100) { xc >>= 8; msb += 8; }
    if (xc >= 0x10) { xc >>= 4; msb += 4; }
    if (xc >= 0x4) { xc >>= 2; msb += 2; }
    if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

    int256 result = msb - 64 << 64;
    uint256 ux = uint256 (x) << uint256 (127 - msb);
    for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
      ux *= ux;
      uint256 b = ux >> 255;
      ux >>= 127 + b;
      result += bit * int256 (b);
    }

    return int128 (result);
  }

  /**
   * Calculate natural logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function ln (int128 x) internal pure returns (int128) {
    require (x > 0);

    return int128 (
        uint256 (log_2 (x)) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128);
  }

  /**
   * Calculate binary exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp_2 (int128 x) internal pure returns (int128) {
    require (x < 0x400000000000000000); // Overflow

    if (x < -0x400000000000000000) return 0; // Underflow

    uint256 result = 0x80000000000000000000000000000000;

    if (x & 0x8000000000000000 > 0)
      result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
    if (x & 0x4000000000000000 > 0)
      result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
    if (x & 0x2000000000000000 > 0)
      result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
    if (x & 0x1000000000000000 > 0)
      result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
    if (x & 0x800000000000000 > 0)
      result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
    if (x & 0x400000000000000 > 0)
      result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
    if (x & 0x200000000000000 > 0)
      result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
    if (x & 0x100000000000000 > 0)
      result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
    if (x & 0x80000000000000 > 0)
      result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
    if (x & 0x40000000000000 > 0)
      result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
    if (x & 0x20000000000000 > 0)
      result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
    if (x & 0x10000000000000 > 0)
      result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
    if (x & 0x8000000000000 > 0)
      result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
    if (x & 0x4000000000000 > 0)
      result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
    if (x & 0x2000000000000 > 0)
      result = result * 0x1000162E525EE054754457D5995292026 >> 128;
    if (x & 0x1000000000000 > 0)
      result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
    if (x & 0x800000000000 > 0)
      result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
    if (x & 0x400000000000 > 0)
      result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
    if (x & 0x200000000000 > 0)
      result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
    if (x & 0x100000000000 > 0)
      result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
    if (x & 0x80000000000 > 0)
      result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
    if (x & 0x40000000000 > 0)
      result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
    if (x & 0x20000000000 > 0)
      result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
    if (x & 0x10000000000 > 0)
      result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
    if (x & 0x8000000000 > 0)
      result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
    if (x & 0x4000000000 > 0)
      result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
    if (x & 0x2000000000 > 0)
      result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
    if (x & 0x1000000000 > 0)
      result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
    if (x & 0x800000000 > 0)
      result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
    if (x & 0x400000000 > 0)
      result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
    if (x & 0x200000000 > 0)
      result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
    if (x & 0x100000000 > 0)
      result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
    if (x & 0x80000000 > 0)
      result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
    if (x & 0x40000000 > 0)
      result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
    if (x & 0x20000000 > 0)
      result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
    if (x & 0x10000000 > 0)
      result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
    if (x & 0x8000000 > 0)
      result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
    if (x & 0x4000000 > 0)
      result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
    if (x & 0x2000000 > 0)
      result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
    if (x & 0x1000000 > 0)
      result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
    if (x & 0x800000 > 0)
      result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
    if (x & 0x400000 > 0)
      result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
    if (x & 0x200000 > 0)
      result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
    if (x & 0x100000 > 0)
      result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
    if (x & 0x80000 > 0)
      result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
    if (x & 0x40000 > 0)
      result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
    if (x & 0x20000 > 0)
      result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
    if (x & 0x10000 > 0)
      result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
    if (x & 0x8000 > 0)
      result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
    if (x & 0x4000 > 0)
      result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
    if (x & 0x2000 > 0)
      result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
    if (x & 0x1000 > 0)
      result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
    if (x & 0x800 > 0)
      result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
    if (x & 0x400 > 0)
      result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
    if (x & 0x200 > 0)
      result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
    if (x & 0x100 > 0)
      result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
    if (x & 0x80 > 0)
      result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
    if (x & 0x40 > 0)
      result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
    if (x & 0x20 > 0)
      result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
    if (x & 0x10 > 0)
      result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
    if (x & 0x8 > 0)
      result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
    if (x & 0x4 > 0)
      result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
    if (x & 0x2 > 0)
      result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
    if (x & 0x1 > 0)
      result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;

    result >>= uint256 (63 - (x >> 64));
    require (result <= uint256 (MAX_64x64));

    return int128 (result);
  }

  /**
   * Calculate natural exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp (int128 x) internal pure returns (int128) {
    require (x < 0x400000000000000000); // Overflow

    if (x < -0x400000000000000000) return 0; // Underflow

    return exp_2 (
        int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128));
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return unsigned 64.64-bit fixed point number
   */
  function divuu (uint256 x, uint256 y) private pure returns (uint128) {
    require (y != 0);

    uint256 result;

    if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
      result = (x << 64) / y;
    else {
      uint256 msb = 192;
      uint256 xc = x >> 192;
      if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
      if (xc >= 0x10000) { xc >>= 16; msb += 16; }
      if (xc >= 0x100) { xc >>= 8; msb += 8; }
      if (xc >= 0x10) { xc >>= 4; msb += 4; }
      if (xc >= 0x4) { xc >>= 2; msb += 2; }
      if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

      result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1);
      require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

      uint256 hi = result * (y >> 128);
      uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

      uint256 xh = x >> 192;
      uint256 xl = x << 64;

      if (xl < lo) xh -= 1;
      xl -= lo; // We rely on overflow behavior here
      lo = hi << 128;
      if (xl < lo) xh -= 1;
      xl -= lo; // We rely on overflow behavior here

      assert (xh == hi >> 128);

      result += xl / y;
    }

    require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
    return uint128 (result);
  }

  /**
   * Calculate x^y assuming 0^0 is 1, where x is unsigned 129.127 fixed point
   * number and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x unsigned 129.127-bit fixed point number
   * @param y uint256 value
   * @return unsigned 129.127-bit fixed point number
   */
  function powu (uint256 x, uint256 y) private pure returns (uint256) {
    if (y == 0) return 0x80000000000000000000000000000000;
    else if (x == 0) return 0;
    else {
      int256 msb = 0;
      uint256 xc = x;
      if (xc >= 0x100000000000000000000000000000000) { xc >>= 128; msb += 128; }
      if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
      if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
      if (xc >= 0x10000) { xc >>= 16; msb += 16; }
      if (xc >= 0x100) { xc >>= 8; msb += 8; }
      if (xc >= 0x10) { xc >>= 4; msb += 4; }
      if (xc >= 0x4) { xc >>= 2; msb += 2; }
      if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

      int256 xe = msb - 127;
      if (xe > 0) x >>= uint256 (xe);
      else x <<= uint256 (-xe);

      uint256 result = 0x80000000000000000000000000000000;
      int256 re = 0;

      while (y > 0) {
        if (y & 1 > 0) {
          result = result * x;
          y -= 1;
          re += xe;
          if (result >=
            0x8000000000000000000000000000000000000000000000000000000000000000) {
            result >>= 128;
            re += 1;
          } else result >>= 127;
          if (re < -127) return 0; // Underflow
          require (re < 128); // Overflow
        } else {
          x = x * x;
          y >>= 1;
          xe <<= 1;
          if (x >=
            0x8000000000000000000000000000000000000000000000000000000000000000) {
            x >>= 128;
            xe += 1;
          } else x >>= 127;
          if (xe < -127) return 0; // Underflow
          require (xe < 128); // Overflow
        }
      }

      if (re > 0) result <<= uint256 (re);
      else if (re < 0) result >>= uint256 (-re);

      return result;
    }
  }

  /**
   * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
   * number.
   *
   * @param x unsigned 256-bit integer number
   * @return unsigned 128-bit integer number
   */
  function sqrtu (uint256 x) private pure returns (uint128) {
    if (x == 0) return 0;
    else {
      uint256 xx = x;
      uint256 r = 1;
      if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; }
      if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; }
      if (xx >= 0x100000000) { xx >>= 32; r <<= 16; }
      if (xx >= 0x10000) { xx >>= 16; r <<= 8; }
      if (xx >= 0x100) { xx >>= 8; r <<= 4; }
      if (xx >= 0x10) { xx >>= 4; r <<= 2; }
      if (xx >= 0x8) { r <<= 1; }
      r = (r + x / r) >> 1;
      r = (r + x / r) >> 1;
      r = (r + x / r) >> 1;
      r = (r + x / r) >> 1;
      r = (r + x / r) >> 1;
      r = (r + x / r) >> 1;
      r = (r + x / r) >> 1; // Seven iterations should be enough
      uint256 r1 = x / r;
      return uint128 (r < r1 ? r : r1);
    }
  }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >= 0.4.22 <0.9.0;

library console {
	address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);

	function _sendLogPayload(bytes memory payload) private view {
		uint256 payloadLength = payload.length;
		address consoleAddress = CONSOLE_ADDRESS;
		assembly {
			let payloadStart := add(payload, 32)
			let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
		}
	}

	function log() internal view {
		_sendLogPayload(abi.encodeWithSignature("log()"));
	}

	function logInt(int p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(int)", p0));
	}

	function logUint(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function logString(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function logBool(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function logAddress(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function logBytes(bytes memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
	}

	function logBytes1(bytes1 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
	}

	function logBytes2(bytes2 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
	}

	function logBytes3(bytes3 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
	}

	function logBytes4(bytes4 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
	}

	function logBytes5(bytes5 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
	}

	function logBytes6(bytes6 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
	}

	function logBytes7(bytes7 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
	}

	function logBytes8(bytes8 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
	}

	function logBytes9(bytes9 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
	}

	function logBytes10(bytes10 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
	}

	function logBytes11(bytes11 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
	}

	function logBytes12(bytes12 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
	}

	function logBytes13(bytes13 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
	}

	function logBytes14(bytes14 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
	}

	function logBytes15(bytes15 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
	}

	function logBytes16(bytes16 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
	}

	function logBytes17(bytes17 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
	}

	function logBytes18(bytes18 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
	}

	function logBytes19(bytes19 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
	}

	function logBytes20(bytes20 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
	}

	function logBytes21(bytes21 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
	}

	function logBytes22(bytes22 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
	}

	function logBytes23(bytes23 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
	}

	function logBytes24(bytes24 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
	}

	function logBytes25(bytes25 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
	}

	function logBytes26(bytes26 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
	}

	function logBytes27(bytes27 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
	}

	function logBytes28(bytes28 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
	}

	function logBytes29(bytes29 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
	}

	function logBytes30(bytes30 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
	}

	function logBytes31(bytes31 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
	}

	function logBytes32(bytes32 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
	}

	function log(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function log(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function log(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function log(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function log(uint p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
	}

	function log(uint p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
	}

	function log(uint p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
	}

	function log(uint p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
	}

	function log(string memory p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
	}

	function log(string memory p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
	}

	function log(string memory p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
	}

	function log(string memory p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
	}

	function log(bool p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
	}

	function log(bool p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
	}

	function log(bool p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
	}

	function log(bool p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
	}

	function log(address p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
	}

	function log(address p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
	}

	function log(address p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
	}

	function log(address p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
	}

	function log(uint p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
	}

	function log(uint p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
	}

	function log(uint p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
	}

	function log(uint p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
	}

	function log(uint p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
	}

	function log(uint p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
	}

	function log(uint p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
	}

	function log(uint p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
	}

	function log(uint p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
	}

	function log(uint p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
	}

	function log(uint p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
	}

	function log(uint p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
	}

	function log(string memory p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
	}

	function log(string memory p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
	}

	function log(string memory p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
	}

	function log(string memory p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
	}

	function log(bool p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
	}

	function log(bool p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
	}

	function log(bool p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
	}

	function log(bool p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
	}

	function log(bool p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
	}

	function log(bool p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
	}

	function log(bool p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
	}

	function log(bool p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
	}

	function log(bool p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
	}

	function log(bool p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
	}

	function log(bool p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
	}

	function log(bool p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
	}

	function log(address p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
	}

	function log(address p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
	}

	function log(address p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
	}

	function log(address p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
	}

	function log(address p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
	}

	function log(address p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
	}

	function log(address p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
	}

	function log(address p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
	}

	function log(address p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
	}

	function log(address p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
	}

	function log(address p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
	}

	function log(address p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
	}

	function log(address p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
	}

	function log(address p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
	}

	function log(address p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
	}

	function log(address p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
	}

	function log(uint p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
	}

}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "./Context.sol";
import "./IERC20.sol";
import "./SafeMath.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal virtual {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

interface IATokenV2 {
    function ATOKEN_REVISION() external view returns (uint256);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function EIP712_REVISION() external view returns (bytes memory);

    function PERMIT_TYPEHASH() external view returns (bytes32);

    function POOL() external view returns (address);

    function RESERVE_TREASURY_ADDRESS() external view returns (address);

    function UINT_MAX_VALUE() external view returns (uint256);

    function UNDERLYING_ASSET_ADDRESS() external view returns (address);

    function _nonces(address) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function balanceOf(address user) external view returns (uint256);

    function burn(
        address user,
        address receiverOfUnderlying,
        uint256 amount,
        uint256 index
    ) external;

    function decimals() external view returns (uint8);

    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);

    function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256);

    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);

    function initialize(
        uint8 underlyingAssetDecimals,
        string memory tokenName,
        string memory tokenSymbol
    ) external;

    function mint(
        address user,
        uint256 amount,
        uint256 index
    ) external returns (bool);

    function mintToTreasury(uint256 amount, uint256 index) external;

    function name() external view returns (string memory);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    function scaledBalanceOf(address user) external view returns (uint256);

    function scaledTotalSupply() external view returns (uint256);

    function symbol() external view returns (string memory);

    function totalSupply() external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    function transferOnLiquidation(
        address from,
        address to,
        uint256 value
    ) external;

    function transferUnderlyingTo(address target, uint256 amount) external returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

interface IBasket {
    function transfer(address dst, uint256 amount) external returns (bool);

    function totalSupply() external view returns (uint256);

    function mint(uint256) external;

    function getOne() external view returns (address[] memory, uint256[] memory);

    function getAssetsAndBalances() external view returns (address[] memory, uint256[] memory);

    function burn(uint256) external;

    function viewMint(uint256 _amountOut) external view returns (uint256[] memory _amountsIn);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

interface ICToken {
    function _acceptAdmin() external returns (uint256);

    function _addReserves(uint256 addAmount) external returns (uint256);

    function _reduceReserves(uint256 reduceAmount) external returns (uint256);

    function _setComptroller(address newComptroller) external returns (uint256);

    function _setImplementation(
        address implementation_,
        bool allowResign,
        bytes memory becomeImplementationData
    ) external;

    function _setInterestRateModel(address newInterestRateModel) external returns (uint256);

    function _setPendingAdmin(address newPendingAdmin) external returns (uint256);

    function _setReserveFactor(uint256 newReserveFactorMantissa) external returns (uint256);

    function accrualBlockNumber() external view returns (uint256);

    function accrueInterest() external returns (uint256);

    function admin() external view returns (address);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function balanceOf(address owner) external view returns (uint256);

    function balanceOfUnderlying(address owner) external returns (uint256);

    function borrow(uint256 borrowAmount) external returns (uint256);

    function borrowBalanceCurrent(address account) external returns (uint256);

    function borrowBalanceStored(address account) external view returns (uint256);

    function borrowIndex() external view returns (uint256);

    function borrowRatePerBlock() external view returns (uint256);

    function comptroller() external view returns (address);

    function decimals() external view returns (uint8);

    function delegateToImplementation(bytes memory data) external returns (bytes memory);

    function delegateToViewImplementation(bytes memory data) external view returns (bytes memory);

    function exchangeRateCurrent() external returns (uint256);

    function exchangeRateStored() external view returns (uint256);

    function getAccountSnapshot(address account)
        external
        view
        returns (
            uint256,
            uint256,
            uint256,
            uint256
        );

    function getCash() external view returns (uint256);

    function implementation() external view returns (address);

    function interestRateModel() external view returns (address);

    function isCToken() external view returns (bool);

    function liquidateBorrow(
        address borrower,
        uint256 repayAmount,
        address cTokenCollateral
    ) external returns (uint256);

    function mint(uint256 mintAmount) external returns (uint256);

    function name() external view returns (string memory);

    function pendingAdmin() external view returns (address);

    function redeem(uint256 redeemTokens) external returns (uint256);

    function redeemUnderlying(uint256 redeemAmount) external returns (uint256);

    function repayBorrow(uint256 repayAmount) external returns (uint256);

    function repayBorrowBehalf(address borrower, uint256 repayAmount) external returns (uint256);

    function reserveFactorMantissa() external view returns (uint256);

    function seize(
        address liquidator,
        address borrower,
        uint256 seizeTokens
    ) external returns (uint256);

    function supplyRatePerBlock() external view returns (uint256);

    function symbol() external view returns (string memory);

    function totalBorrows() external view returns (uint256);

    function totalBorrowsCurrent() external returns (uint256);

    function totalReserves() external view returns (uint256);

    function totalSupply() external view returns (uint256);

    function transfer(address dst, uint256 amount) external returns (bool);

    function transferFrom(
        address src,
        address dst,
        uint256 amount
    ) external returns (bool);

    function underlying() external view returns (address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

interface ICurvePool {
    function exchange(
        int128 i,
        int128 j,
        uint256 _dx,
        uint256 _min_dy
    ) external;

    function get_dy(
        int128 i,
        int128 j,
        uint256 _dx
    ) external view returns (uint256);

    function get_virtual_price() external view returns (uint256);
}

interface ICurveLINK {
    function A() external view returns (uint256);

    function A_precise() external view returns (uint256);

    function get_virtual_price() external view returns (uint256);

    function calc_token_amount(uint256[2] memory _amounts, bool _is_deposit) external view returns (uint256);

    function add_liquidity(uint256[2] memory _amounts, uint256 _min_mint_amount) external returns (uint256);

    function get_dy(
        int128 i,
        int128 j,
        uint256 _dx
    ) external view returns (uint256);

    function exchange(
        int128 i,
        int128 j,
        uint256 _dx,
        uint256 _min_dy
    ) external returns (uint256);

    function remove_liquidity(uint256 _amount, uint256[2] memory _min_amounts) external returns (uint256[2] memory);

    function remove_liquidity_imbalance(uint256[2] memory _amounts, uint256 _max_burn_amount)
        external
        returns (uint256);

    function calc_withdraw_one_coin(uint256 _token_amount, int128 i) external view returns (uint256);

    function remove_liquidity_one_coin(
        uint256 _token_amount,
        int128 i,
        uint256 _min_amount
    ) external returns (uint256);

    function ramp_A(uint256 _future_A, uint256 _future_time) external;

    function stop_ramp_A() external;

    function commit_new_fee(uint256 _new_fee, uint256 _new_admin_fee) external;

    function apply_new_fee() external;

    function revert_new_parameters() external;

    function commit_transfer_ownership(address _owner) external;

    function apply_transfer_ownership() external;

    function revert_transfer_ownership() external;

    function admin_balances(uint256 i) external view returns (uint256);

    function withdraw_admin_fees() external;

    function donate_admin_fees() external;

    function kill_me() external;

    function unkill_me() external;

    function coins(uint256 arg0) external view returns (address);

    function balances(uint256 arg0) external view returns (uint256);

    function fee() external view returns (uint256);

    function admin_fee() external view returns (uint256);

    function previous_balances(uint256 arg0) external view returns (uint256);

    function block_timestamp_last() external view returns (uint256);

    function owner() external view returns (address);

    function lp_token() external view returns (address);

    function initial_A() external view returns (uint256);

    function future_A() external view returns (uint256);

    function initial_A_time() external view returns (uint256);

    function future_A_time() external view returns (uint256);

    function admin_actions_deadline() external view returns (uint256);

    function transfer_ownership_deadline() external view returns (uint256);

    function future_fee() external view returns (uint256);

    function future_admin_fee() external view returns (uint256);

    function future_owner() external view returns (address);
}

interface ILinkGauge {
    function decimals() external view returns (uint256);

    function integrate_checkpoint() external view returns (uint256);

    function user_checkpoint(address addr) external returns (bool);

    function claimable_tokens(address addr) external returns (uint256);

    function claimable_reward(address _addr, address _token) external returns (uint256);

    function claim_rewards() external;

    function claim_rewards(address _addr) external;

    function claim_historic_rewards(address[8] memory _reward_tokens) external;

    function claim_historic_rewards(address[8] memory _reward_tokens, address _addr) external;

    function kick(address addr) external;

    function set_approve_deposit(address addr, bool can_deposit) external;

    function deposit(uint256 _value) external;

    function deposit(uint256 _value, address _addr) external;

    function withdraw(uint256 _value) external;

    function allowance(address _owner, address _spender) external view returns (uint256);

    function transfer(address _to, uint256 _value) external returns (bool);

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    ) external returns (bool);

    function approve(address _spender, uint256 _value) external returns (bool);

    function increaseAllowance(address _spender, uint256 _added_value) external returns (bool);

    function decreaseAllowance(address _spender, uint256 _subtracted_value) external returns (bool);

    function set_rewards(
        address _reward_contract,
        bytes32 _sigs,
        address[8] memory _reward_tokens
    ) external;

    function set_killed(bool _is_killed) external;

    function commit_transfer_ownership(address addr) external;

    function accept_transfer_ownership() external;

    function minter() external view returns (address);

    function crv_token() external view returns (address);

    function lp_token() external view returns (address);

    function controller() external view returns (address);

    function voting_escrow() external view returns (address);

    function future_epoch_time() external view returns (uint256);

    function balanceOf(address arg0) external view returns (uint256);

    function totalSupply() external view returns (uint256);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function approved_to_deposit(address arg0, address arg1) external view returns (bool);

    function working_balances(address arg0) external view returns (uint256);

    function working_supply() external view returns (uint256);

    function period() external view returns (int128);

    function period_timestamp(uint256 arg0) external view returns (uint256);

    function integrate_inv_supply(uint256 arg0) external view returns (uint256);

    function integrate_inv_supply_of(address arg0) external view returns (uint256);

    function integrate_checkpoint_of(address arg0) external view returns (uint256);

    function integrate_fraction(address arg0) external view returns (uint256);

    function inflation_rate() external view returns (uint256);

    function reward_contract() external view returns (address);

    function reward_tokens(uint256 arg0) external view returns (address);

    function reward_integral(address arg0) external view returns (uint256);

    function reward_integral_for(address arg0, address arg1) external view returns (uint256);

    function admin() external view returns (address);

    function future_admin() external view returns (address);

    function is_killed() external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

interface ICurveZapSimple {
    function add_liquidity(uint256[3] memory _deposit_amounts, uint256 _min_mint_amount) external;

    function add_liquidity(
        uint256[3] memory _deposit_amounts,
        uint256 _min_mint_amount,
        bool use_underlying
    ) external;

    function add_liquidity(uint256[4] memory _deposit_amounts, uint256 _min_mint_amount) external;

    function add_liquidity(
        address _pool,
        uint256[4] memory _deposit_amounts,
        uint256 _min_mint_amount
    ) external returns (uint256);

    function add_liquidity(
        address _pool,
        uint256[4] memory _deposit_amounts,
        uint256 _min_mint_amount,
        address _receiver
    ) external returns (uint256);

    function remove_liquidity_one_coin(
        uint256 _token_amount,
        int128 i,
        uint256 min_amount,
        bool _donate_dust
    ) external;

    function remove_liquidity_one_coin(
        uint256 _token_amount,
        int128 i,
        uint256 min_amount
    ) external;

    function remove_liquidity_one_coin(
        address pool,
        uint256 _token_amount,
        int128 i,
        uint256 min_amount,
        address _receiver
    ) external returns (uint256);

    function remove_liquidity_one_coin(
        uint256 _token_amount,
        int128 i,
        uint256 min_amount,
        address _receiver
    ) external returns (uint256);

    function calc_withdraw_one_coin(uint256 _token_amount, int128 i) external view returns (uint256);

    function calc_withdraw_one_coin(
        uint256 _token_amount,
        int128 i,
        bool use_underlying
    ) external view returns (uint256);

    function calc_withdraw_one_coin(
        address pool,
        uint256 _token_amount,
        int128 i
    ) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

interface ILendingPoolV2 {
    function FLASHLOAN_PREMIUM_TOTAL() external view returns (uint256);

    function LENDINGPOOL_REVISION() external view returns (uint256);

    function MAX_NUMBER_RESERVES() external view returns (uint256);

    function MAX_STABLE_RATE_BORROW_SIZE_PERCENT() external view returns (uint256);

    function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        uint16 referralCode,
        address onBehalfOf
    ) external;

    function deposit(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode
    ) external;

    function finalizeTransfer(
        address asset,
        address from,
        address to,
        uint256 amount,
        uint256 balanceFromBefore,
        uint256 balanceToBefore
    ) external;

    function flashLoan(
        address receiverAddress,
        address[] memory assets,
        uint256[] memory amounts,
        uint256[] memory modes,
        address onBehalfOf,
        bytes memory params,
        uint16 referralCode
    ) external;

    function getAddressesProvider() external view returns (address);

    function getConfiguration(address asset) external view returns (uint256);

    function getReserveData(address asset)
        external
        view
        returns (
            uint256,
            uint128,
            uint128,
            uint128,
            uint128,
            uint128,
            uint40,
            address,
            address,
            address,
            address,
            uint8
        );

    function getReserveNormalizedIncome(address asset) external view returns (uint256);

    function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);

    function getReservesList() external view returns (address[] memory);

    function getUserAccountData(address user)
        external
        view
        returns (
            uint256 totalCollateralETH,
            uint256 totalDebtETH,
            uint256 availableBorrowsETH,
            uint256 currentLiquidationThreshold,
            uint256 ltv,
            uint256 healthFactor
        );

    function initReserve(
        address asset,
        address aTokenAddress,
        address stableDebtAddress,
        address variableDebtAddress,
        address interestRateStrategyAddress
    ) external;

    function initialize(address provider) external;

    function liquidationCall(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover,
        bool receiveAToken
    ) external;

    function paused() external view returns (bool);

    function rebalanceStableBorrowRate(address asset, address user) external;

    function repay(
        address asset,
        uint256 amount,
        uint256 rateMode,
        address onBehalfOf
    ) external returns (uint256);

    function setConfiguration(address asset, uint256 configuration) external;

    function setPause(bool val) external;

    function setReserveInterestRateStrategyAddress(address asset, address rateStrategyAddress) external;

    function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;

    function swapBorrowRateMode(address asset, uint256 rateMode) external;

    function withdraw(
        address asset,
        uint256 amount,
        address to
    ) external returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

interface IYearn {
    function initialize(
        address token,
        address governance,
        address rewards,
        string memory nameOverride,
        string memory symbolOverride
    ) external;

    function initialize(
        address token,
        address governance,
        address rewards,
        string memory nameOverride,
        string memory symbolOverride,
        address guardian
    ) external;

    function apiVersion() external pure returns (string memory);

    function setName(string memory name) external;

    function setSymbol(string memory symbol) external;

    function setGovernance(address governance) external;

    function acceptGovernance() external;

    function setManagement(address management) external;

    function setGuestList(address guestList) external;

    function setRewards(address rewards) external;

    function setLockedProfitDegration(uint256 degration) external;

    function setDepositLimit(uint256 limit) external;

    function setPerformanceFee(uint256 fee) external;

    function setManagementFee(uint256 fee) external;

    function setGuardian(address guardian) external;

    function setEmergencyShutdown(bool active) external;

    function setWithdrawalQueue(address[20] memory queue) external;

    function transfer(address receiver, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address receiver,
        uint256 amount
    ) external returns (bool);

    function approve(address spender, uint256 amount) external returns (bool);

    function increaseAllowance(address spender, uint256 amount) external returns (bool);

    function decreaseAllowance(address spender, uint256 amount) external returns (bool);

    function permit(
        address owner,
        address spender,
        uint256 amount,
        uint256 expiry,
        bytes memory signature
    ) external returns (bool);

    function totalAssets() external view returns (uint256);

    function deposit() external returns (uint256);

    function deposit(uint256 _amount) external returns (uint256);

    function deposit(uint256 _amount, address recipient) external returns (uint256);

    function maxAvailableShares() external view returns (uint256);

    function withdraw() external returns (uint256);

    function withdraw(uint256 maxShares) external returns (uint256);

    function withdraw(uint256 maxShares, address recipient) external returns (uint256);

    function withdraw(
        uint256 maxShares,
        address recipient,
        uint256 maxLoss
    ) external returns (uint256);

    function pricePerShare() external view returns (uint256);

    function addStrategy(
        address strategy,
        uint256 debtRatio,
        uint256 minDebtPerHarvest,
        uint256 maxDebtPerHarvest,
        uint256 performanceFee
    ) external;

    function updateStrategyDebtRatio(address strategy, uint256 debtRatio) external;

    function updateStrategyMinDebtPerHarvest(address strategy, uint256 minDebtPerHarvest) external;

    function updateStrategyMaxDebtPerHarvest(address strategy, uint256 maxDebtPerHarvest) external;

    function updateStrategyPerformanceFee(address strategy, uint256 performanceFee) external;

    function migrateStrategy(address oldVersion, address newVersion) external;

    function revokeStrategy() external;

    function revokeStrategy(address strategy) external;

    function addStrategyToQueue(address strategy) external;

    function removeStrategyFromQueue(address strategy) external;

    function debtOutstanding() external view returns (uint256);

    function debtOutstanding(address strategy) external view returns (uint256);

    function creditAvailable() external view returns (uint256);

    function creditAvailable(address strategy) external view returns (uint256);

    function availableDepositLimit() external view returns (uint256);

    function expectedReturn() external view returns (uint256);

    function expectedReturn(address strategy) external view returns (uint256);

    function report(
        uint256 gain,
        uint256 loss,
        uint256 _debtPayment
    ) external returns (uint256);

    function sweep(address token) external;

    function sweep(address token, uint256 amount) external;

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint256);

    function precisionFactor() external view returns (uint256);

    function balanceOf(address arg0) external view returns (uint256);

    function allowance(address arg0, address arg1) external view returns (uint256);

    function totalSupply() external view returns (uint256);

    function token() external view returns (address);

    function governance() external view returns (address);

    function management() external view returns (address);

    function guardian() external view returns (address);

    function guestList() external view returns (address);

    function strategies(address arg0)
        external
        view
        returns (
            uint256 performanceFee,
            uint256 activation,
            uint256 debtRatio,
            uint256 minDebtPerHarvest,
            uint256 maxDebtPerHarvest,
            uint256 lastReport,
            uint256 totalDebt,
            uint256 totalGain,
            uint256 totalLoss
        );

    function withdrawalQueue(uint256 arg0) external view returns (address);

    function emergencyShutdown() external view returns (bool);

    function depositLimit() external view returns (uint256);

    function debtRatio() external view returns (uint256);

    function totalDebt() external view returns (uint256);

    function lastReport() external view returns (uint256);

    function activation() external view returns (uint256);

    function lockedProfit() external view returns (uint256);

    function lockedProfitDegration() external view returns (uint256);

    function rewards() external view returns (address);

    function managementFee() external view returns (uint256);

    function performanceFee() external view returns (uint256);

    function nonces(address arg0) external view returns (uint256);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "./Context.sol";
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "./IERC20.sol";
import "./SafeMath.sol";
import "./Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_bmi","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"BMI","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"calcUSDCEquilavent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_derivative","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"getUnderlyingAmount","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_tokens","type":"address[]"}],"name":"recoverERC20s","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_fromUnderlying","type":"address"},{"internalType":"uint256","name":"_fromUnderlyingAmount","type":"uint256"},{"internalType":"uint256","name":"_minBMIRecv","type":"uint256"},{"internalType":"address[]","name":"_bmiConstituents","type":"address[]"},{"internalType":"uint256[]","name":"_bmiConstituentsWeightings","type":"uint256[]"},{"internalType":"address","name":"_aggregator","type":"address"},{"internalType":"bytes","name":"_aggregatorData","type":"bytes"},{"internalType":"bool","name":"refundDust","type":"bool"}],"name":"zapToBMI","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000ac00355f80e289f53bf368c9bdb70f5c114c44b

-----Decoded View---------------
Arg [0] : _bmi (address): 0x0aC00355F80E289f53BF368C9Bdb70f5c114C44B

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000ac00355f80e289f53bf368c9bdb70f5c114c44b

413:23997:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6856:1545;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;6856:1545:2;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;720:18;;;:::i;:::-;;;;-1:-1:-1;;;;;720:18:2;;;;;;;;;;;;;;8407:1546;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;8407:1546:2;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;8407:1546:2;;;;;;;;;;;;;;;;;;;;;1710:145:13;;;:::i;:::-;;1078:85;;;:::i;6350:152:2:-;;;;;;;;;;;;;;;;-1:-1:-1;6350:152:2;-1:-1:-1;;;;;6350:152:2;;:::i;9996:3736::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9996:3736:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9996:3736:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9996:3736:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9996:3736:2;;;;;;;;-1:-1:-1;9996:3736:2;;-1:-1:-1;;;;;9996:3736:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9996:3736:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9996:3736:2;;-1:-1:-1;;;;;9996:3736:2;;;;;;;;-1:-1:-1;9996:3736:2;;;;-1:-1:-1;9996:3736:2;;;;-1:-1:-1;;;;9996:3736:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9996:3736:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9996:3736:2;;-1:-1:-1;;;;9996:3736:2;;;;-1:-1:-1;9996:3736:2;:::i;6508:240::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;6508:240:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;6508:240:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6508:240:2;;-1:-1:-1;6508:240:2;;-1:-1:-1;;;;;6508:240:2:i;2004::13:-;;;;;;;;;;;;;;;;-1:-1:-1;2004:240:13;-1:-1:-1;;;;;2004:240:13;;:::i;6856:1545:2:-;6937:7;6960:18;6972:5;6960:11;:18::i;:::-;6956:154;;;7004:52;7051:4;7004:42;7023:5;-1:-1:-1;;;;;7016:27:2;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7016:29:2;7004:7;;:11;:42::i;:::-;:46;;:52::i;:::-;6994:62;;7085:5;-1:-1:-1;;;;;7078:19:2;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7078:21:2;;-1:-1:-1;6956:154:2;-1:-1:-1;;;;;7124:13:2;;3738:42;7124:13;;:33;;-1:-1:-1;;;;;;7141:16:2;;3965:42;7141:16;7124:33;:54;;;-1:-1:-1;;;;;;7161:17:2;;4435:42;7161:17;7124:54;:75;;;-1:-1:-1;;;;;;7182:17:2;;4199:42;7182:17;7124:75;7120:1275;;;3889:42;-1:-1:-1;;;;;7255:16:2;;3965:42;7255:16;7251:230;;;-1:-1:-1;4122:42:2;7251:230;;;-1:-1:-1;;;;;7332:17:2;;4435:42;7332:17;7328:153;;;-1:-1:-1;4515:42:2;7328:153;;;-1:-1:-1;;;;;7412:17:2;;4199:42;7412:17;7408:73;;;-1:-1:-1;4358:42:2;7408:73;7518:3;-1:-1:-1;;;;;7502:43:2;;7546:7;7555:1;7502:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7502:55:2;;-1:-1:-1;7495:62:2;;-1:-1:-1;7495:62:2;7120:1275;-1:-1:-1;;;;;7578:16:2;;5520:42;7578:16;;:36;;-1:-1:-1;;;;;;7598:16:2;;4591:42;7598:16;7578:36;:56;;;-1:-1:-1;;;;;;7618:16:2;;4824:42;7618:16;7578:56;:76;;;-1:-1:-1;;;;;;7638:16:2;;5057:42;7638:16;7578:76;:95;;;-1:-1:-1;;;;;;7658:15:2;;5289:42;7658:15;7578:95;7574:821;;;5677:42;-1:-1:-1;;;;;7732:16:2;;4591:42;7732:16;7728:300;;;-1:-1:-1;4748:42:2;7728:300;;;-1:-1:-1;;;;;7809:16:2;;4824:42;7809:16;7805:223;;;-1:-1:-1;4981:42:2;7805:223;;;-1:-1:-1;;;;;7886:16:2;;5057:42;7886:16;7882:146;;;-1:-1:-1;5214:42:2;7882:146;;;-1:-1:-1;;;;;7963:15:2;;5289:42;7963:15;7959:69;;;-1:-1:-1;5444:42:2;7959:69;8065:3;-1:-1:-1;;;;;8049:43:2;;8093:7;8102:1;8049:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7574:821;-1:-1:-1;;;;;8125:14:2;;5751:42;8125:14;8121:274;;;8162:67;;;-1:-1:-1;;;8162:67:2;;;;;;;;8221:1;8162:67;;;;;;;;;;;;5828:42;;8162:49;;:67;;;;;;;;;;;;;;5828:42;8162:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8162:67:2;;-1:-1:-1;8155:74:2;;8121:274;8312:72;;;-1:-1:-1;;;8312:72:2;;-1:-1:-1;;;;;8312:72:2;;;;;;;;;;;;8382:1;8312:72;;;;;;6212:42;;8312:53;;:72;;;;;;;;;;;;;;6212:42;8312:72;;;;;;;;;;8121:274;6856:1545;;;;:::o;720:18::-;;;-1:-1:-1;;;;;720:18:2;;:::o;8407:1546::-;8495:7;8504;8527:20;8535:11;8527:7;:20::i;:::-;8523:118;;;8581:11;-1:-1:-1;;;;;8571:47:2;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8571:49:2;;-1:-1:-1;8622:7:2;;-1:-1:-1;8563:67:2;;8523:118;8655:24;8667:11;8655;:24::i;:::-;8651:466;;;8695:12;8718:11;-1:-1:-1;;;;;8710:39:2;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8710:41:2;8786:33;;;-1:-1:-1;;;8786:33:2;;;;8710:41;;-1:-1:-1;8765:18:2;;-1:-1:-1;;;;;8786:31:2;;;;;:33;;;;;8710:41;;8786:33;;;;;;;:31;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8786:33:2;8862:28;;;-1:-1:-1;;;8862:28:2;;;;8786:33;;-1:-1:-1;8833:26:2;;-1:-1:-1;;;;;8862:26:2;;;;;:28;;;;;8786:33;;8862:28;;;;;;;:26;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8862:28:2;8833:57;;;-1:-1:-1;8923:27:2;;;;;8904:16;;8996:32;;9015:12;;;8996:14;:4;9005;8996:8;:14::i;:32::-;8964:64;-1:-1:-1;9050:10:2;9062:43;9101:3;9062:34;:7;8964:64;9062:11;:34::i;:43::-;9042:64;;;;;;;;;;;8651:466;9175:19;9182:11;9175:6;:19::i;:::-;:47;;;;9198:24;9210:11;9198;:24::i;:::-;9171:133;;;852:42;9252:40;9271:11;9284:7;9252:18;:40::i;:::-;9238:55;;;;;;9171:133;9318:21;9327:11;9318:8;:21::i;:::-;9314:593;;;9365:58;9418:4;9365:48;9384:11;-1:-1:-1;;;;;9377:33:2;;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9377:35:2;9365:7;;:11;:48::i;:58::-;9355:68;-1:-1:-1;;;;;;9442:19:2;;1587:42;9442:19;9438:79;;;-1:-1:-1;780:42:2;;-1:-1:-1;9494:7:2;9481:21;;9438:79;-1:-1:-1;;;;;9535:20:2;;1660:42;9535:20;9531:81;;;-1:-1:-1;852:42:2;;-1:-1:-1;9589:7:2;9575:22;;9531:81;-1:-1:-1;;;;;9630:20:2;;1733:42;9630:20;9626:81;;;-1:-1:-1;924:42:2;;-1:-1:-1;9684:7:2;9670:22;;9626:81;-1:-1:-1;;;;;9725:20:2;;1806:42;9725:20;9721:81;;;-1:-1:-1;996:42:2;;-1:-1:-1;9779:7:2;9765:22;;9721:81;-1:-1:-1;;;;;9820:20:2;;1879:42;9820:20;9816:81;;;-1:-1:-1;1068:42:2;;-1:-1:-1;9874:7:2;9860:22;;9816:81;-1:-1:-1;9925:11:2;;-1:-1:-1;9938:7:2;8407:1546;;;;;;:::o;1710:145:13:-;1301:12;:10;:12::i;:::-;-1:-1:-1;;;;;1290:23:13;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1290:23:13;;1282:68;;;;;-1:-1:-1;;;1282:68:13;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1282:68:13;;;;;;;;;;;;;;;1816:1:::1;1800:6:::0;;1779:40:::1;::::0;-1:-1:-1;;;;;1800:6:13;;::::1;::::0;1779:40:::1;::::0;1816:1;;1779:40:::1;1846:1;1829:19:::0;;-1:-1:-1;;;;;;1829:19:13::1;::::0;;1710:145::o;1078:85::-;1124:7;1150:6;-1:-1:-1;;;;;1150:6:13;1078:85;:::o;6350:152:2:-;1301:12:13;:10;:12::i;:::-;-1:-1:-1;;;;;1290:23:13;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1290:23:13;;1282:68;;;;;-1:-1:-1;;;1282:68:13;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1282:68:13;;;;;;;;;;;;;;;6415:80:2::1;6443:10;6462:6;-1:-1:-1::0;;;;;6455:24:2::1;;6488:4;6455:39;;;;;;;;;;;;;-1:-1:-1::0;;;;;6455:39:2::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;6455:39:2;-1:-1:-1;;;;;6415:27:2;::::1;::::0;:80;:27:::1;:80::i;:::-;6350:152:::0;:::o;9996:3736::-;10373:7;;;10417:133;10441:26;:33;10437:1;:37;10417:133;;;10501:38;10509:26;10536:1;10509:29;;;;;;;;;;;;;;10501:3;:7;;:38;;;;:::i;:::-;10495:44;-1:-1:-1;10476:3:2;;10417:133;;;;10623:4;10616:3;:11;;10609:19;;;;10652:6;10645:3;:13;;10638:21;;;;10702:66;-1:-1:-1;;;;;10702:30:2;;10733:10;10753:4;10760:7;10702:30;:66::i;:::-;10804:14;10812:5;10804:7;:14::i;:::-;10800:2312;;;10834:107;10850:5;10857:7;10866:16;10884:26;10912:11;10925:15;10834;:107::i;:::-;10800:2312;;;10999:15;11008:5;10999:8;:15::i;:::-;10995:2117;;;11037:5;-1:-1:-1;;;;;11030:22:2;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11068:241:2;;-1:-1:-1;11101:15:2;11134:21;11173:16;11207:26;11251:11;11280:15;11068;:241::i;10995:2117::-;11367:18;11379:5;11367:11;:18::i;:::-;11363:1749;;;11408:5;-1:-1:-1;;;;;11401:22:2;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;11458:21:2;;;-1:-1:-1;;;11458:21:2;;;;11439:16;;-1:-1:-1;;;;;11458:19:2;;;;;:21;;;;;11401:24;;11458:21;;;;;;;;:19;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11458:21:2;11519:41;;;-1:-1:-1;;;11519:41:2;;11554:4;11519:41;;;;;;11458:21;;-1:-1:-1;11493:68:2;;11458:21;;-1:-1:-1;;;;;11519:26:2;;;;;:41;;;;;11458:21;;11519:41;;;;;;;;:26;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11519:41:2;11493:15;:68::i;:::-;11630:37;;;-1:-1:-1;;;11630:37:2;;11661:4;11630:37;;;;;;11575:232;;852:42;;;;11630:22;;:37;;;;;;;;;;;;;;852:42;11630:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11630:37:2;11575:232;;;11630:37;11575:232;;;;;11771:1;11575:232;;;11685:16;;11719:26;;11771:1;11575:15;:232::i;:::-;11363:1749;;;;11856:18;11868:5;11856:11;:18::i;:::-;11852:1260;;;11906:5;-1:-1:-1;;;;;11898:21:2;;11920:7;11898:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11898:30:2;:35;11890:62;;;;;-1:-1:-1;;;11890:62:2;;;;;;;;;;;;-1:-1:-1;;;11890:62:2;;;;;;;;;;;;;;;11966:241;11999:15;12032:21;12071:16;12105:26;12149:11;12178:15;11966;:241::i;11852:1260::-;12252:14;12260:5;12252:7;:14::i;:::-;12248:864;;;12282:50;-1:-1:-1;;;;;12282:25:2;;645:42;12330:1;12282:25;:50::i;:::-;12346:56;-1:-1:-1;;;;;12346:25:2;;645:42;12394:7;12346:25;:56::i;:::-;12416:96;;;-1:-1:-1;;;12416:96:2;;-1:-1:-1;;;;;12416:96:2;;;;;;-1:-1:-1;;12416:96:2;;;;12506:4;12416:96;;;;;;645:42;;12416:45;;:96;;;;;;;;;;;;;;-1:-1:-1;645:42:2;12416:96;;;;;;;;;;12248:864;12824:31;12840:5;12847:7;12824:15;:31::i;:::-;12924:37;;;-1:-1:-1;;;12924:37:2;;12955:4;12924:37;;;;;;12869:232;;852:42;;;;12924:22;;:37;;;;;;;;;;;;;;852:42;12924:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12924:37:2;12869:232;;;12924:37;12869:232;;;;;13065:1;12869:232;;;12979:16;;13013:26;;13065:1;12869:15;:232::i;:::-;13165:3;;13158:36;;;-1:-1:-1;;;13158:36:2;;13188:4;13158:36;;;;;;13140:15;;-1:-1:-1;;;;;13165:3:2;;13158:21;;:36;;;;;;;;;;;;;;13165:3;13158:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13158:36:2;;-1:-1:-1;13212:22:2;;;;13204:44;;;;;-1:-1:-1;;;13204:44:2;;;;;;;;;;;;-1:-1:-1;;;13204:44:2;;;;;;;;;;;;;;;13265:3;;13258:45;;-1:-1:-1;;;;;13265:3:2;13283:10;13295:7;13258:24;:45::i;:::-;13388:10;13384:317;;;13419:9;13414:187;13438:16;:23;13434:1;:27;13414:187;;;13486:100;13512:16;13529:1;13512:19;;;;;;;;;;;;;;13540:16;13557:1;13540:19;;;;;;;;;;;;;;-1:-1:-1;;;;;13533:37:2;;13579:4;13533:52;;;;;;;;;;;;;-1:-1:-1;;;;;13533:52:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13533:52:2;13486:25;:100::i;:::-;13463:3;;13414:187;;;-1:-1:-1;13652:37:2;;;-1:-1:-1;;;13652:37:2;;13683:4;13652:37;;;;;;13614:76;;13640:10;;852:42;;13652:22;;:37;;;;;;;;;;;;;;852:42;13652:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13652:37:2;852:42;;13614:76;:25;:76::i;:::-;13718:7;9996:3736;-1:-1:-1;;;;;;;;;;;;9996:3736:2:o;6508:240::-;1301:12:13;:10;:12::i;:::-;-1:-1:-1;;;;;1290:23:13;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1290:23:13;;1282:68;;;;;-1:-1:-1;;;1282:68:13;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1282:68:13;;;;;;;;;;;;;;;6589:9:2::1;6584:158;6608:7;:14;6604:1;:18;6584:158;;;6643:88;6675:10;6694:7;6702:1;6694:10;;;;;;;;;;;;;;-1:-1:-1::0;;;;;6687:28:2::1;;6724:4;6687:43;;;;;;;;;;;;;-1:-1:-1::0;;;;;6687:43:2::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;6687:43:2;6650:10;;:7;;6658:1;;6650:10;::::1;;;;;;;;;;;-1:-1:-1::0;;;;;6643:31:2::1;;;:88;;;;;:::i;:::-;6624:3;;6584:158;;;;6508:240:::0;:::o;2004::13:-;1301:12;:10;:12::i;:::-;-1:-1:-1;;;;;1290:23:13;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1290:23:13;;1282:68;;;;;-1:-1:-1;;;1282:68:13;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1282:68:13;;;;;;;;;;;;;;;-1:-1:-1;;;;;2092:22:13;::::1;2084:73;;;;-1:-1:-1::0;;;2084:73:13::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2193:6;::::0;;2172:38:::1;::::0;-1:-1:-1;;;;;2172:38:13;;::::1;::::0;2193:6;::::1;::::0;2172:38:::1;::::0;::::1;2220:6;:17:::0;;-1:-1:-1;;;;;;2220:17:13::1;-1:-1:-1::0;;;;;2220:17:13;;;::::1;::::0;;;::::1;::::0;;2004:240::o;22971:548:2:-;23031:4;-1:-1:-1;;;;;23055:14:2;;1969:42;23055:14;;:48;;-1:-1:-1;;;;;;23085:18:2;;2055:42;23085:18;23055:48;:83;;;-1:-1:-1;;;;;;23119:19:2;;2132:42;23119:19;23055:83;:117;;;-1:-1:-1;;;;;;23154:18:2;;2208:42;23154:18;23055:117;:151;;;-1:-1:-1;;;;;;23188:18:2;;2284:42;23188:18;23055:151;:185;;;-1:-1:-1;;;;;;23222:18:2;;2360:42;23222:18;23055:185;:220;;;-1:-1:-1;;;;;;23256:19:2;;2437:42;23256:19;23055:220;:254;;;-1:-1:-1;;;;;;23291:18:2;;2513:42;23291:18;23055:254;:288;;;-1:-1:-1;;;;;;23325:18:2;;2589:42;23325:18;23055:288;:323;;;-1:-1:-1;;;;;;23359:19:2;;2740:42;23359:19;23055:323;:355;;;-1:-1:-1;;;;;;23394:16:2;;2663:42;23394:16;23055:355;:389;;;-1:-1:-1;;;;;;23426:18:2;;2892:42;23426:18;23055:389;:422;;;-1:-1:-1;;;;;;23460:17:2;;2967:42;23460:17;23055:422;:456;;;-1:-1:-1;;;;;;23493:18:2;;2816:42;23493:18;23047:465;22971:548;-1:-1:-1;;22971:548:2:o;3538:215:15:-;3596:7;3619:6;3615:20;;-1:-1:-1;3634:1:15;3627:8;;3615:20;3657:5;;;3661:1;3657;:5;:1;3680:5;;;;;:10;3672:56;;;;-1:-1:-1;;;3672:56:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3745:1;3538:215;-1:-1:-1;;;3538:215:15:o;4217:150::-;4275:7;4306:1;4302;:5;4294:44;;;;;-1:-1:-1;;;4294:44:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;4359:1;4355;:5;;;;;;;4217:150;-1:-1:-1;;;4217:150:15:o;24230:178:2:-;24286:4;-1:-1:-1;;;;;24310:14:2;;3052:42;24310:14;;:33;;-1:-1:-1;;;;;;24328:15:2;;3125:42;24328:15;24310:33;:52;;;-1:-1:-1;;;;;;24347:15:2;;3198:42;24347:15;24310:52;:71;;;-1:-1:-1;;;;;;24366:15:2;;3271:42;24366:15;24310:71;:90;;;-1:-1:-1;;;;;;;24385:15:2;3344:42;24385:15;;24230:178::o;24061:163::-;24121:4;-1:-1:-1;;;;;24145:14:2;;3433:42;24145:14;;:33;;-1:-1:-1;;;;;;24163:15:2;;3506:42;24163:15;24145:33;:52;;;-1:-1:-1;;;;;;24182:15:2;;3579:42;24182:15;24145:52;:71;;;-1:-1:-1;;;;;;;24201:15:2;3652:42;24201:15;;24061:163::o;23525:530::-;23580:4;-1:-1:-1;;;;;23604:14:2;;3738:42;23604:14;;:47;;-1:-1:-1;;;;;;23634:17:2;;3965:42;23634:17;23604:47;:81;;;-1:-1:-1;;;;;;23667:18:2;;4199:42;23667:18;23604:81;:114;;;-1:-1:-1;;;;;;23701:17:2;;5904:42;23701:17;23604:114;:147;;;-1:-1:-1;;;;;;23734:17:2;;4591:42;23734:17;23604:147;:180;;;-1:-1:-1;;;;;;23767:17:2;;5979:42;23767:17;23604:180;:214;;;-1:-1:-1;;;;;;23800:18:2;;6055:42;23800:18;23604:214;:247;;;-1:-1:-1;;;;;;23834:17:2;;6130:42;23834:17;23604:247;:281;;;-1:-1:-1;;;;;;23867:18:2;;4435:42;23867:18;23604:281;:314;;;-1:-1:-1;;;;;;23901:17:2;;5520:42;23901:17;23604:314;:347;;;-1:-1:-1;;;;;;23934:17:2;;4824:42;23934:17;23604:347;:380;;;-1:-1:-1;;;;;;23967:17:2;;5057:42;23967:17;23604:380;:412;;;-1:-1:-1;;;;;;24000:16:2;;5289:42;24000:16;23604:412;:443;;;-1:-1:-1;;;;;;;24032:15:2;5751:42;24032:15;;23525:530::o;22786:179::-;22843:4;-1:-1:-1;;;;;22867:14:2;;1587:42;22867:14;;:33;;-1:-1:-1;;;;;;22885:15:2;;1660:42;22885:15;22867:33;:52;;;-1:-1:-1;;;;;;22904:15:2;;1733:42;22904:15;22867:52;:71;;;-1:-1:-1;;;;;;22923:15:2;;1806:42;22923:15;22867:71;:90;;;-1:-1:-1;;;;;;;22942:15:2;1879:42;22942:15;;22786:179::o;598:104:3:-;685:10;598:104;:::o;685:175:14:-;794:58;;;-1:-1:-1;;;;;794:58:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;794:58:14;-1:-1:-1;;;794:58:14;;;767:86;;787:5;;767:19;:86::i;:::-;685:175;;;:::o;2690::15:-;2748:7;2779:5;;;2802:6;;;;2794:46;;;;;-1:-1:-1;;;2794:46:15;;;;;;;;;;;;;;;;;;;;;;;;;;;866:203:14;993:68;;;-1:-1:-1;;;;;993:68:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;993:68:14;-1:-1:-1;;;993:68:14;;;966:96;;986:5;;966:19;:96::i;:::-;866:203;;;;:::o;22378:402:2:-;22434:4;-1:-1:-1;;;;;22458:13:2;;780:42;22458:13;;:43;;-1:-1:-1;;;;;;22487:14:2;;852:42;22487:14;22458:43;:73;;;-1:-1:-1;;;;;;22517:14:2;;924:42;22517:14;22458:73;:103;;;-1:-1:-1;;;;;;22547:14:2;;996:42;22547:14;22458:103;:133;;;-1:-1:-1;;;;;;22577:14:2;;1068:42;22577:14;22458:133;:163;;;-1:-1:-1;;;;;;22607:14:2;;1140:42;22607:14;22458:163;:193;;;-1:-1:-1;;;;;;22637:14:2;;1212:42;22637:14;22458:193;:223;;;-1:-1:-1;;;;;;22667:14:2;;1284:42;22667:14;22458:223;:254;;;-1:-1:-1;;;;;;22697:15:2;;1357:42;22697:15;22458:254;:284;;;-1:-1:-1;;;;;;22728:14:2;;1429:42;22728:14;22458:284;:314;;;-1:-1:-1;;;;;;;22758:14:2;1501:42;22758:14;;22378:402::o;15775:1613::-;16084:14;-1:-1:-1;;;;;16168:13:2;;780:42;16168:13;;;;:31;;-1:-1:-1;;;;;;16185:14:2;;852:42;16185:14;;16168:31;:49;;;;-1:-1:-1;;;;;;16203:14:2;;924:42;16203:14;;16168:49;16164:383;;;16233:42;-1:-1:-1;;;;;16233:26:2;;16260:11;16273:1;16233:26;:42::i;:::-;16289:48;-1:-1:-1;;;;;16289:26:2;;16316:11;16329:7;16289:26;:48::i;:::-;16353:12;16371:11;-1:-1:-1;;;;;16371:16:2;16388:15;16371:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;16371:33:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16352:52;;;16426:7;16418:25;;;;;-1:-1:-1;;;16418:25:2;;;;;;;;;;;;-1:-1:-1;;;16418:25:2;;;;;;;;;;;;;;;852:42;16523:13;;16164:383;;-1:-1:-1;;;;;16561:14:2;;852:42;16561:14;16557:116;;;-1:-1:-1;16600:1:2;16557:116;;;-1:-1:-1;;;;;16622:14:2;;924:42;16622:14;16618:55;;;-1:-1:-1;16661:1:2;16618:55;16709:20;16739:17;16766:3;;;;;;;;;-1:-1:-1;;;;;16766:3:2;-1:-1:-1;;;;;16759:23:2;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16759:25:2;16814:39;;;-1:-1:-1;;;16814:39:2;;16847:4;16814:39;;;;;;16759:25;;-1:-1:-1;16795:16:2;;-1:-1:-1;;;;;16814:24:2;;;;;:39;;;;;16759:25;;16814:39;;;;;;;:24;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16814:39:2;;-1:-1:-1;16863:19:2;;16892:427;16916:16;:23;16912:1;:27;16892:427;;;17033:53;17081:4;17033:43;17046:26;17073:1;17046:29;;;;;;;;;;;;;;17033:8;:12;;:43;;;;:::i;:53::-;17019:67;;17100;17118:6;17126:16;17143:1;17126:19;;;;;;;;;;;;;;17147:11;17160:6;17100:17;:67::i;:::-;17231:77;17263:9;17274:16;17291:1;17274:19;;;;;;;;;;;;;;17295:12;17231:31;:77::i;:::-;17216:92;-1:-1:-1;16941:3:2;;16892:427;;;-1:-1:-1;17358:3:2;;17350:31;;;-1:-1:-1;;;17350:31:2;;;;;;;;;;-1:-1:-1;;;;;17358:3:2;;;;17350:17;;:31;;;;;17358:3;;17350:31;;;;;;;;17358:3;;17350:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15775:1613;;;;;;;;;;;:::o;13773:1996::-;-1:-1:-1;;;;;13887:13:2;;3738:42;13887:13;;:33;;-1:-1:-1;;;;;;13904:16:2;;3965:42;13904:16;13887:33;:54;;;-1:-1:-1;;;;;;13924:17:2;;4199:42;13924:17;13887:54;13883:1880;;;3889:42;-1:-1:-1;;;;;13997:16:2;;3965:42;13997:16;13993:150;;;-1:-1:-1;4122:42:2;13993:150;;;-1:-1:-1;;;;;14074:17:2;;4199:42;14074:17;14070:73;;;-1:-1:-1;4358:42:2;14070:73;14157:33;-1:-1:-1;;;;;14157:25:2;;14183:3;14188:1;14157:25;:33::i;:::-;14204:39;-1:-1:-1;;;;;14204:25:2;;14230:3;14235:7;14204:25;:39::i;:::-;14257:68;;;-1:-1:-1;;;14257:68:2;;;;;;;;14313:1;14257:68;;;;14316:1;14257:68;;;;;;;;;;;;;;-1:-1:-1;;;;;14257:46:2;;;;;:68;;;;;;;;;;;14316:1;14257:46;:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13883:1880;;;;-1:-1:-1;;;;;14346:16:2;;4591:42;14346:16;;:36;;-1:-1:-1;;;;;;14366:16:2;;5520:42;14366:16;14346:36;:56;;;-1:-1:-1;;;;;;14386:16:2;;4824:42;14386:16;14346:56;:76;;;-1:-1:-1;;;;;;14406:16:2;;5057:42;14406:16;14346:76;:95;;;-1:-1:-1;;;;;;14426:15:2;;5289:42;14426:15;14346:95;14342:1421;;;5677:42;-1:-1:-1;;;;;14500:16:2;;4591:42;14500:16;14496:300;;;-1:-1:-1;4748:42:2;14496:300;;;-1:-1:-1;;;;;14577:16:2;;4824:42;14577:16;14573:223;;;-1:-1:-1;4981:42:2;14573:223;;;-1:-1:-1;;;;;14654:16:2;;5057:42;14654:16;14650:146;;;-1:-1:-1;5214:42:2;14650:146;;;-1:-1:-1;;;;;14731:15:2;;5289:42;14731:15;14727:69;;;-1:-1:-1;5444:42:2;14727:69;14810:33;-1:-1:-1;;;;;14810:25:2;;14836:3;14841:1;14810:25;:33::i;:::-;14857:39;-1:-1:-1;;;;;14857:25:2;;14883:3;14888:7;14857:25;:39::i;:::-;14910:61;;;-1:-1:-1;;;14910:61:2;;;;;;;;14966:1;14910:61;;;;14969:1;14910:61;;;;;;;;-1:-1:-1;;;;;14910:46:2;;;;;:61;;;;;;;;;;;14969:1;14910:46;:61;;;;;;;;;;14342:1421;-1:-1:-1;;;;;14992:14:2;;5751:42;14992:14;14988:775;;;15022:39;-1:-1:-1;;;;;15022:25:2;;5828:42;15059:1;15022:25;:39::i;:::-;15075:45;-1:-1:-1;;;;;15075:25:2;;5828:42;15112:7;15075:25;:45::i;:::-;15134:73;;;-1:-1:-1;;;15134:73:2;;;;;;;;15196:1;15134:73;;;;;;15199:1;15134:73;;;;;;;;;;;;;;;5828:42;;15134:52;;:73;;;;;;;;;;;15199:1;5828:42;15134:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14988:775;;;-1:-1:-1;;;;;15228:17:2;;4435:42;15228:17;15224:539;;;4515:42;15302:33;-1:-1:-1;;;;;15302:25:2;;4515:42;15261:11;15302:25;:33::i;:::-;15349:39;-1:-1:-1;;;;;15349:25:2;;15375:3;15380:7;15349:25;:39::i;:::-;15402:61;;;-1:-1:-1;;;15402:61:2;;;;;;;;15458:1;15402:61;;;;15461:1;15402:61;;;;;;;;-1:-1:-1;;;;;15402:46:2;;;;;:61;;;;;;;;;;;15461:1;15402:46;:61;;;;;;;;;;15224:539;15539:43;-1:-1:-1;;;;;15539:25:2;;6212:42;15580:1;15539:25;:43::i;:::-;15596:49;-1:-1:-1;;;;;15596:25:2;;6212:42;15637:7;15596:25;:49::i;:::-;15659:93;;;-1:-1:-1;;;15659:93:2;;-1:-1:-1;;;;;15659:93:2;;;;;;;;;;;;15732:1;15659:93;;;;15735:1;15659:93;;;;;;15746:4;15659:93;;;;;;6212:42;;15659:56;;:93;;;;;;;;;;;;;;;;;;6212:42;15659:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1329:613:14;1694:10;;;1693:62;;-1:-1:-1;1710:39:14;;;-1:-1:-1;;;1710:39:14;;1734:4;1710:39;;;;-1:-1:-1;;;;;1710:39:14;;;;;;;;;:15;;;;;;:39;;;;;;;;;;;;;;;:15;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1710:39:14;:44;1693:62;1685:150;;;;-1:-1:-1;;;1685:150:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1872:62;;;-1:-1:-1;;;;;1872:62:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1872:62:14;-1:-1:-1;;;1872:62:14;;;1845:90;;1865:5;;1845:19;:90::i;22140:232:2:-;22235:23;22247:10;22235:11;:23::i;:::-;22231:135;;;22274:81;22297:10;-1:-1:-1;;;;;22290:24:2;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22290:26:2;22318:36;;;-1:-1:-1;;;22318:36:2;;;;;;;;;;-1:-1:-1;;;;;22318:27:2;;;;;:36;;;;;22290:26;;22318:36;;;;;;;-1:-1:-1;22318:27:2;:36;;;;;;;;;;;;;;;;;;;;;;;;;;2948:751:14;3367:23;3393:69;3421:4;3393:69;;;;;;;;;;;;;;;;;3401:5;-1:-1:-1;;;;;3393:27:14;;;:69;;;;;:::i;:::-;3476:17;;3367:95;;-1:-1:-1;3476:21:14;3472:221;;3616:10;3605:30;;;;;;;;;;;;;;;-1:-1:-1;3605:30:14;3597:85;;;;-1:-1:-1;;;3597:85:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18231:3903:2;18392:11;18413:33;;:::i;:::-;:84;;;;;;;;18458:1;18413:84;;;;18470:1;18413:84;;;;18482:1;18413:84;;;;18494:1;18413:84;;;;;1879:42;-1:-1:-1;;;;;18512:17:2;:8;-1:-1:-1;;;;;18512:17:2;;18508:3583;;;18545:46;-1:-1:-1;;;;;18545:30:2;;4044:42;18589:1;18545:30;:46::i;:::-;18605:52;-1:-1:-1;;;;;18605:30:2;;4044:42;18649:7;18605:30;:52::i;:::-;18672:69;;;-1:-1:-1;;;18672:69:2;;;;;;;;;;18727:1;18672:69;;;;;;;;;;18739:1;18672:69;;;;;;;;4044:42;;18672:32;;:69;;;;;;;;;;;18739:1;4044:42;18672:69;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;18762:37:2;;;-1:-1:-1;;;18762:37:2;;18793:4;18762:37;;;;;;1068:42;;-1:-1:-1;18762:22:2;;-1:-1:-1;18762:37:2;;;;;;;;;;;;;;1068:42;18762:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18762:37:2;;-1:-1:-1;18813:34:2;1068:42;1879;18845:1;18813:24;:34::i;:::-;18861:36;1068:42;1879;18893:3;18861:24;:36::i;:::-;18508:3583;;;-1:-1:-1;;;;;18962:16:2;;1969:42;18962:16;;:52;;-1:-1:-1;;;;;;18994:20:2;;2055:42;18994:20;18962:52;:89;;;-1:-1:-1;;;;;;19030:21:2;;2132:42;19030:21;18962:89;:125;;;-1:-1:-1;;;;;;19067:20:2;;2589:42;19067:20;18962:125;:161;;;-1:-1:-1;;;;;;19103:20:2;;2284:42;19103:20;18962:161;:197;;;-1:-1:-1;;;;;;19139:20:2;;2816:42;19139:20;18962:197;:233;;;-1:-1:-1;;;;;;19175:20:2;;2892:42;19175:20;18962:233;:268;;;-1:-1:-1;;;;;;19211:19:2;;2967:42;19211:19;18962:268;18945:3146;;;19255:16;19281:8;-1:-1:-1;;;;;19274:22:2;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19274:24:2;;-1:-1:-1;3889:42:2;-1:-1:-1;;;;;19352:20:2;;2055:42;19352:20;19348:736;;;-1:-1:-1;4122:42:2;19348:736;;;-1:-1:-1;;;;;19433:21:2;;2132:42;19433:21;19429:655;;;-1:-1:-1;4358:42:2;19429:655;;;-1:-1:-1;;;;;19516:20:2;;2589:42;19516:20;19512:572;;;5677:42;19556:16;;19606:1;19590:17;;;;19512:572;;;-1:-1:-1;;;;;19632:20:2;;2284:42;19632:20;19628:456;;;4748:42;19672:16;;19722:1;19706:17;;;;19628:456;;;-1:-1:-1;;;;;19748:20:2;;2816:42;19748:20;19744:340;;;4981:42;19788:16;;19838:1;19822:17;;;;19744:340;;;-1:-1:-1;;;;;19864:20:2;;2892:42;19864:20;19860:224;;;5214:42;19904:16;;19954:1;19938:17;;;;19860:224;;;-1:-1:-1;;;;;19980:19:2;;2967:42;19980:19;19976:108;;;5444:42;20019:15;;20068:1;20052:17;;;;19976:108;20130:7;20098:15;20114:12;20098:29;;;;;;;;;;:39;20151:38;-1:-1:-1;;;;;20151:30:2;;20182:3;20187:1;20151:30;:38::i;:::-;20203:44;-1:-1:-1;;;;;20203:30:2;;20234:3;20239:7;20203:30;:44::i;:::-;20261:54;;-1:-1:-1;;;20261:54:2;;-1:-1:-1;;;;;20261:34:2;;;;;20296:15;;20313:1;;20261:54;;;20296:15;20261:54;;;20296:15;20313:1;20261:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;20336:41:2;;;-1:-1:-1;;;20336:41:2;;20371:4;20336:41;;;;;;-1:-1:-1;;;;;20336:26:2;;;-1:-1:-1;20336:26:2;;-1:-1:-1;20336:41:2;;;;;;;;;;;;;;:26;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20336:41:2;;-1:-1:-1;20391:41:2;-1:-1:-1;;;;;20391:28:2;;20420:8;20430:1;20391:28;:41::i;:::-;20446:43;-1:-1:-1;;;;;20446:28:2;;20475:8;20485:3;20446:28;:43::i;:::-;18945:3146;;;;;-1:-1:-1;;;;;20510:21:2;;2740:42;20510:21;;:43;;-1:-1:-1;;;;;;20535:18:2;;2663:42;20535:18;20510:43;20506:1585;;;20569:16;20595:8;-1:-1:-1;;;;;20588:22:2;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20588:24:2;;-1:-1:-1;20627:33:2;;:::i;:::-;:72;;;;;;;;20672:1;20627:72;;;;20684:1;20627:72;;;;20696:1;20627:72;;;;;20745:7;20713:15;20729:12;20713:29;;;;;;;;;;:39;4515:42;-1:-1:-1;;;;;20811:18:2;;2663:42;20811:18;20807:72;;;-1:-1:-1;5828:42:2;20807:72;20893:38;-1:-1:-1;;;;;20893:30:2;;20924:3;20929:1;20893:30;:38::i;:::-;20945:44;-1:-1:-1;;;;;20945:30:2;;20976:3;20981:7;20945:30;:44::i;:::-;-1:-1:-1;;;;;21008:21:2;;2740:42;21008:21;21004:213;;;21049:54;;-1:-1:-1;;;21049:54:2;;-1:-1:-1;;;;;21049:34:2;;;;;21084:15;;21101:1;;21049:54;;;21084:15;21049:54;;;21084:15;21101:1;21049:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21004:213;;;21142:60;;-1:-1:-1;;;21142:60:2;;-1:-1:-1;;;;;21142:34:2;;;;;21177:15;;21194:1;;21197:4;;21142:60;;;21177:15;21142:60;;;21177:15;21194:1;21142:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21004:213;21237:41;;;-1:-1:-1;;;21237:41:2;;21272:4;21237:41;;;;;;-1:-1:-1;;;;;21237:26:2;;;;;:41;;;;;;;;;;;;;;:26;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21237:41:2;;-1:-1:-1;21292:41:2;-1:-1:-1;;;;;21292:28:2;;21321:8;21331:1;21292:28;:41::i;:::-;21347:43;-1:-1:-1;;;;;21347:28:2;;21376:8;21386:3;21347:28;:43::i;:::-;20506:1585;;;;;;-1:-1:-1;;;;;21441:20:2;;2208:42;21441:20;;:44;;-1:-1:-1;;;;;;21465:20:2;;2360:42;21465:20;21441:44;:69;;;-1:-1:-1;;;;;;21489:21:2;;2437:42;21489:21;21441:69;:93;;;-1:-1:-1;;;;;;21514:20:2;;2513:42;21514:20;21441:93;21437:654;;;21586:16;21612:8;-1:-1:-1;;;;;21605:22:2;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21605:24:2;;-1:-1:-1;21680:7:2;21644:15;21675:1;21660:16;;21644:33;;;;;;;;;;:43;21701:48;-1:-1:-1;;;;;21701:30:2;;6212:42;21747:1;21701:30;:48::i;:::-;21763:54;-1:-1:-1;;;;;21763:30:2;;6212:42;21809:7;21763:30;:54::i;:::-;21832:74;;-1:-1:-1;;;21832:74:2;;-1:-1:-1;;;;;21832:74:2;;;;;;;;6212:42;;21832:44;;21877:8;;21887:15;;21904:1;;21832:74;;21887:15;21832:74;;;21887:15;21904:1;21832:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;21927:41:2;;;-1:-1:-1;;;21927:41:2;;21962:4;21927:41;;;;;;-1:-1:-1;;;;;21927:26:2;;;;;:41;;;;;21832:74;;21927:41;;;;;;;:26;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21927:41:2;;-1:-1:-1;21982:41:2;-1:-1:-1;;;;;21982:28:2;;22011:8;22021:1;21982:28;:41::i;:::-;22037:43;-1:-1:-1;;;;;22037:28:2;;22066:8;22076:3;22037:28;:43::i;:::-;21437:654;;22108:8;-1:-1:-1;;;;;22101:24:2;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;18231:3903:2:o;17394:831::-;17558:7;17577:11;17598:16;-1:-1:-1;;;;;17591:34:2;;17634:4;17591:49;;;;;;;;;;;;;-1:-1:-1;;;;;17591:49:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17591:49:2;17702:3;;17667:39;;;-1:-1:-1;;;17667:39:2;;-1:-1:-1;;;;;17702:3:2;;;17667:39;;;;;;17591:49;;-1:-1:-1;17650:14:2;;17667:34;;;;;;:39;;;;;17591:49;;17667:39;;;;;;;;:34;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17667:39:2;17754:3;;17667:39;;-1:-1:-1;17717:44:2;;-1:-1:-1;;;;;17717:36:2;;;;17754:3;;17717:36;:44::i;:::-;17808:3;;17771:46;;-1:-1:-1;;;;;17771:36:2;;;;17808:3;17813;17771:36;:46::i;:::-;17964:19;17960:93;;18006:36;18035:6;18006:24;:15;18026:3;18006:19;:24::i;:36::-;17999:43;;;;;;17960:93;18063:12;18078:36;18107:6;18078:24;:15;18098:3;18078:19;:24::i;:36::-;18063:51;;18135:14;18128:4;:21;18124:63;;;18172:4;-1:-1:-1;18165:11:2;;-1:-1:-1;;18165:11:2;18124:63;-1:-1:-1;18204:14:2;;17394:831;-1:-1:-1;;;;;17394:831:2:o;3581:193:1:-;3684:12;3715:52;3737:6;3745:4;3751:1;3754:12;3715:21;:52::i;:::-;3708:59;3581:193;-1:-1:-1;;;;3581:193:1:o;4608:523::-;4735:12;4792:5;4767:21;:30;;4759:81;;;;-1:-1:-1;;;4759:81:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4858:18;4869:6;4858:10;:18::i;:::-;4850:60;;;;;-1:-1:-1;;;4850:60:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;4981:12;4995:23;5022:6;-1:-1:-1;;;;;5022:11:1;5042:5;5050:4;5022:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5022:33:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4980:75;;;;5072:52;5090:7;5099:10;5111:12;5072:17;:52::i;:::-;5065:59;4608:523;-1:-1:-1;;;;;;;4608:523:1:o;726:413::-;1086:20;1124:8;;;726:413::o;7091:725::-;7206:12;7234:7;7230:580;;;-1:-1:-1;7264:10:1;7257:17;;7230:580;7375:17;;:21;7371:429;;7633:10;7627:17;7693:15;7680:10;7676:2;7672:19;7665:44;7582:145;7772:12;7765:20;;-1:-1:-1;;;7765:20:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o

ipfs://33e9355696bcfd1ba774271aec3af9ca02213c13906a4a63cbd092b335ae3001