Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "BaseConicPool.sol";
import "IPoolAdapter.sol";

contract ConicEthPool is BaseConicPool {
    using EnumerableSet for EnumerableSet.AddressSet;
    using ScaledMath for uint256;

    constructor(
        address _underlying,
        IRewardManager _rewardManager,
        address _controller,
        string memory _lpTokenName,
        string memory _symbol,
        address _cvx,
        address _crv
    ) BaseConicPool(_underlying, _rewardManager, _controller, _lpTokenName, _symbol, _cvx, _crv) {}

    function _updatePriceCache() internal override {
        address[] memory underlyings = getAllUnderlyingCoins();
        IOracle priceOracle_ = controller.priceOracle();
        uint256 ethUsdPrice_ = priceOracle_.getUSDPrice(address(0));
        for (uint256 i; i < underlyings.length; i++) {
            address coin = underlyings[i];
            uint256 priceInUsd_ = priceOracle_.getUSDPrice(coin);
            _cachedPrices[coin] = priceInUsd_.divDown(ethUsdPrice_);
        }
    }

    function _isAssetDepegged(address asset_) internal view override returns (bool) {
        // ETH has no sense of peg per se, so always return false for it
        if (asset_ == address(underlying)) return false;

        uint256 cachedPrice_ = _cachedPrices[asset_];
        IOracle priceOracle_ = controller.priceOracle();
        uint256 ethUsdPrice_ = priceOracle_.getUSDPrice(address(0));
        uint256 currentPriceUsd_ = priceOracle_.getUSDPrice(asset_);
        uint256 currentPrice_ = currentPriceUsd_.divDown(ethUsdPrice_);
        uint256 priceDiff_ = cachedPrice_.absSub(currentPrice_);
        uint256 priceDiffPercent_ = priceDiff_.divDown(cachedPrice_);
        return priceDiffPercent_ > depegThreshold;
    }

    function runSanityChecks() public override {
        ICurveRegistryCache curveRegistryCache = controller.curveRegistryCache();
        address[] memory pools = weightManager.allPools();
        for (uint256 i; i < pools.length; i++) {
            address pool_ = pools[i];
            controller.poolAdapterFor(pool_).executeSanityCheck(pool_);
            address basePool = curveRegistryCache.basePool(pool_);
            if (basePool != address(0)) {
                controller.poolAdapterFor(basePool).executeSanityCheck(basePool);
            }
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "Ownable.sol";
import "ERC20.sol";
import "Address.sol";
import "EnumerableSet.sol";
import "EnumerableMap.sol";
import "IERC20.sol";
import "SafeERC20.sol";
import "IERC20Metadata.sol";
import "ERC165Checker.sol";

import "IConicPool.sol";
import "IRewardManager.sol";
import "IWithdrawalProcessor.sol";
import "ICurveRegistryCache.sol";
import "IInflationManager.sol";
import "ILpTokenStaker.sol";
import "IOracle.sol";
import "IBaseRewardPool.sol";

import "LpToken.sol";
import "Pausable.sol";
import "ConicPoolWeightManager.sol";

import "ScaledMath.sol";
import "ArrayExtensions.sol";

abstract contract BaseConicPool is IConicPool, Pausable {
    using ArrayExtensions for uint256[];
    using ArrayExtensions for address[];
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableMap for EnumerableMap.AddressToUintMap;
    using SafeERC20 for IERC20;
    using SafeERC20 for IERC20Metadata;
    using SafeERC20 for ILpToken;
    using ScaledMath for uint256;
    using Address for address;
    using ERC165Checker for address;

    // Avoid stack depth errors
    struct DepositVars {
        uint256 exchangeRate;
        uint256 underlyingBalanceIncrease;
        uint256 mintableUnderlyingAmount;
        uint256 lpReceived;
        uint256 underlyingBalanceBefore;
        uint256 allocatedBalanceBefore;
        uint256[] allocatedPerPoolBefore;
        uint256 underlyingBalanceAfter;
        uint256 allocatedBalanceAfter;
        uint256[] allocatedPerPoolAfter;
    }

    uint256 internal constant _IDLE_RATIO_UPPER_BOUND = 0.2e18;
    uint256 internal constant _MIN_DEPEG_THRESHOLD = 0.01e18;
    uint256 internal constant _MAX_DEPEG_THRESHOLD = 0.1e18;
    uint256 internal constant _MAX_DEVIATION_UPPER_BOUND = 0.2e18;
    uint256 internal constant _TOTAL_UNDERLYING_CACHE_EXPIRY = 3 days;
    uint256 internal constant _MAX_USD_VALUE_FOR_REMOVING_POOL = 100e18;
    uint256 internal constant _MIN_EMERGENCY_REBALANCING_REWARD_FACTOR = 1e18;
    uint256 internal constant _MAX_EMERGENCY_REBALANCING_REWARD_FACTOR = 100e18;

    IERC20 internal immutable CVX;
    IERC20 internal immutable CRV;
    IERC20 internal constant CNC = IERC20(0x9aE380F0272E2162340a5bB646c354271c0F5cFC);
    address internal constant _WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    IERC20Metadata public immutable override underlying;
    ILpToken public immutable override lpToken;

    IRewardManager public immutable rewardManager;
    IConicPoolWeightManager public immutable weightManager;

    /// @dev once the deviation gets under this threshold, the reward distribution will be paused
    /// until the next rebalancing. This is expressed as a ratio, scaled with 18 decimals
    uint256 public maxDeviation = 0.02e18; // 2%
    uint256 public maxIdleCurveLpRatio = 0.05e18; // triggers Convex staking when exceeded
    bool public isShutdown;
    uint256 public depegThreshold = 0.03e18; // 3%
    uint256 internal _cacheUpdatedTimestamp;
    uint256 internal _cachedTotalUnderlying;

    /// @dev `true` if the rebalancing rewards are enabled, i.e. can become active
    /// A pool starts rebalancing rewards disabled, and these need to be enabled through governance
    bool public rebalancingRewardsEnabled;

    /// @dev `true` while the reward distribution is active
    bool public rebalancingRewardActive;

    /// @notice the time at which rebalancing rewards have been activated
    uint64 public rebalancingRewardsActivatedAt;

    /// @notice The factor by which the rebalancing reward is multiplied when a pool is depegged
    uint256 public emergencyRebalancingRewardsFactor = 10e18;

    /// @notice The factor by which the rebalancing reward is multiplied
    /// this is 1 (scaled to 18 decimals) for normal rebalancing situations but is set
    /// to `emergencyRebalancingRewardsFactor` when a pool is depegged
    uint256 public rebalancingRewardsFactor;

    /// @dev the absolute value in terms of USD of the total deviation after
    /// the weights have been updated
    uint256 public totalDeviationAfterWeightUpdate;

    mapping(address => uint256) _cachedPrices;

    modifier onlyController() {
        require(msg.sender == address(controller), "not authorized");
        _;
    }

    constructor(
        address _underlying,
        IRewardManager _rewardManager,
        address _controller,
        string memory _lpTokenName,
        string memory _symbol,
        address _cvx,
        address _crv
    ) Pausable(IController(_controller)) {
        require(
            _underlying != _cvx && _underlying != _crv && _underlying != address(CNC),
            "invalid underlying"
        );
        underlying = IERC20Metadata(_underlying);
        uint8 decimals = IERC20Metadata(_underlying).decimals();
        lpToken = new LpToken(_controller, address(this), decimals, _lpTokenName, _symbol);
        rewardManager = _rewardManager;
        weightManager = new ConicPoolWeightManager(
            IController(_controller),
            IERC20Metadata(_underlying)
        );

        CVX = IERC20(_cvx);
        CRV = IERC20(_crv);
        CVX.safeApprove(address(_rewardManager), type(uint256).max);
        CRV.safeApprove(address(_rewardManager), type(uint256).max);
        CNC.safeApprove(address(_rewardManager), type(uint256).max);
    }

    /// @dev We always delegate-call to the Curve handler, which means
    /// that we need to be able to receive the ETH to unwrap it and
    /// send it to the Curve pool, as well as to receive it back from
    /// the Curve pool when withdrawing
    receive() external payable {
        require(address(underlying) == _WETH_ADDRESS, "not WETH pool");
    }

    /// @notice Deposit underlying on behalf of someone
    /// @param underlyingAmount Amount of underlying to deposit
    /// @param minLpReceived The minimum amount of LP to accept from the deposit
    /// @return lpReceived The amount of LP received
    function depositFor(
        address account,
        uint256 underlyingAmount,
        uint256 minLpReceived,
        bool stake
    ) public override notPaused returns (uint256) {
        runSanityChecks();

        DepositVars memory vars;

        // Preparing deposit
        require(!isShutdown, "pool is shut down");
        require(underlyingAmount > 0, "deposit amount cannot be zero");

        _updateAdapterCachedPrices();

        uint256 underlyingPrice_ = controller.priceOracle().getUSDPrice(address(underlying));
        // We use the cached price of LP tokens, which is effectively the latest price
        // because we just updated the cache
        (
            vars.underlyingBalanceBefore,
            vars.allocatedBalanceBefore,
            vars.allocatedPerPoolBefore
        ) = _getTotalAndPerPoolUnderlying(underlyingPrice_, IPoolAdapter.PriceMode.Cached);
        vars.exchangeRate = _exchangeRate(vars.underlyingBalanceBefore);

        // Executing deposit
        underlying.safeTransferFrom(msg.sender, address(this), underlyingAmount);
        _depositToCurve(
            vars.allocatedBalanceBefore,
            vars.allocatedPerPoolBefore,
            underlying.balanceOf(address(this))
        );

        // Minting LP Tokens
        // We use the minimum between the price of the LP tokens before and after deposit
        (
            vars.underlyingBalanceAfter,
            vars.allocatedBalanceAfter,
            vars.allocatedPerPoolAfter
        ) = _getTotalAndPerPoolUnderlying(underlyingPrice_, IPoolAdapter.PriceMode.Minimum);
        vars.underlyingBalanceIncrease = vars.underlyingBalanceAfter - vars.underlyingBalanceBefore;
        vars.mintableUnderlyingAmount = _min(underlyingAmount, vars.underlyingBalanceIncrease);
        vars.lpReceived = vars.mintableUnderlyingAmount.divDown(vars.exchangeRate);
        require(vars.lpReceived >= minLpReceived, "too much slippage");

        _cachedTotalUnderlying = vars.underlyingBalanceAfter;
        _cacheUpdatedTimestamp = block.timestamp;

        if (stake) {
            lpToken.mint(address(this), vars.lpReceived, account);
            ILpTokenStaker lpTokenStaker = controller.lpTokenStaker();
            lpToken.forceApprove(address(lpTokenStaker), vars.lpReceived);
            lpTokenStaker.stakeFor(vars.lpReceived, address(this), account);
        } else {
            lpToken.mint(account, vars.lpReceived, account);
        }

        _handleRebalancingRewards(
            account,
            vars.allocatedBalanceBefore,
            vars.allocatedPerPoolBefore,
            vars.allocatedBalanceAfter,
            vars.allocatedPerPoolAfter
        );

        emit Deposit(msg.sender, account, underlyingAmount, vars.lpReceived);
        return vars.lpReceived;
    }

    /// @notice Deposit underlying
    /// @param underlyingAmount Amount of underlying to deposit
    /// @param minLpReceived The minimum amoun of LP to accept from the deposit
    /// @return lpReceived The amount of LP received
    function deposit(
        uint256 underlyingAmount,
        uint256 minLpReceived
    ) external override returns (uint256) {
        return depositFor(msg.sender, underlyingAmount, minLpReceived, true);
    }

    /// @notice Deposit underlying
    /// @param underlyingAmount Amount of underlying to deposit
    /// @param minLpReceived The minimum amoun of LP to accept from the deposit
    /// @param stake Whether or not to stake in the LpTokenStaker
    /// @return lpReceived The amount of LP received
    function deposit(
        uint256 underlyingAmount,
        uint256 minLpReceived,
        bool stake
    ) external override returns (uint256) {
        return depositFor(msg.sender, underlyingAmount, minLpReceived, stake);
    }

    function _depositToCurve(
        uint256 totalUnderlying_,
        uint256[] memory allocatedPerPool,
        uint256 underlyingAmount_
    ) internal {
        uint256 depositsRemaining_ = underlyingAmount_;
        uint256 totalAfterDeposit_ = totalUnderlying_ + underlyingAmount_;

        // NOTE: avoid modifying `allocatedPerPool`
        uint256[] memory allocatedPerPoolCopy = allocatedPerPool.copy();

        while (depositsRemaining_ > 0) {
            (uint256 poolIndex_, uint256 maxDeposit_) = weightManager.getDepositPool(
                totalAfterDeposit_,
                allocatedPerPoolCopy,
                _getMaxDeviation()
            );
            // account for rounding errors
            if (depositsRemaining_ < maxDeposit_ + 1e2) {
                maxDeposit_ = depositsRemaining_;
            }

            address pool_ = weightManager.getPoolAtIndex(poolIndex_);

            // Depositing into least balanced pool
            uint256 toDeposit_ = _min(depositsRemaining_, maxDeposit_);
            address poolAdapter = address(controller.poolAdapterFor(pool_));
            poolAdapter.functionDelegateCall(
                abi.encodeWithSignature(
                    "deposit(address,address,uint256)",
                    pool_,
                    address(underlying),
                    toDeposit_
                )
            );

            depositsRemaining_ -= toDeposit_;
            allocatedPerPoolCopy[poolIndex_] += toDeposit_;
        }
    }

    /// @notice Get current underlying balance of pool
    function totalUnderlying() public view virtual returns (uint256) {
        (uint256 totalUnderlying_, , ) = getTotalAndPerPoolUnderlying();

        return totalUnderlying_;
    }

    function updateRewardSpendingApproval(address token, bool approved) external {
        require(msg.sender == address(rewardManager), "not authorized");
        uint256 amount = approved ? type(uint256).max : 0;
        IERC20(token).safeApprove(address(rewardManager), amount);
    }

    function _exchangeRate(uint256 totalUnderlying_) internal view returns (uint256) {
        uint256 lpSupply = lpToken.totalSupply();
        if (lpSupply == 0 || totalUnderlying_ == 0) return ScaledMath.ONE;

        return totalUnderlying_.divDown(lpSupply);
    }

    /// @notice Get current exchange rate for the pool's LP token to the underlying
    function exchangeRate() public view virtual override returns (uint256) {
        return _exchangeRate(totalUnderlying());
    }

    /// @notice Get current exchange rate for the pool's LP token to USD
    /// @dev This is using the cached total underlying value, so is not precisely accurate.
    function usdExchangeRate() external view virtual override returns (uint256) {
        uint256 underlyingPrice = controller.priceOracle().getUSDPrice(address(underlying));
        return _exchangeRate(cachedTotalUnderlying()).mulDown(underlyingPrice);
    }

    /// @notice Unstake LP Tokens and withdraw underlying
    /// @param conicLpAmount Amount of LP tokens to burn
    /// @param minUnderlyingReceived Minimum amount of underlying to redeem
    /// This should always be set to a reasonable value (e.g. 2%), otherwise
    /// the user withdrawing could be forced into paying a withdrawal penalty fee
    /// by another user
    /// @return uint256 Total underlying withdrawn
    function unstakeAndWithdraw(
        uint256 conicLpAmount,
        uint256 minUnderlyingReceived,
        address to
    ) public override returns (uint256) {
        controller.lpTokenStaker().unstakeFrom(conicLpAmount, msg.sender);
        return withdraw(conicLpAmount, minUnderlyingReceived, to);
    }

    function unstakeAndWithdraw(
        uint256 conicLpAmount,
        uint256 minUnderlyingReceived
    ) external returns (uint256) {
        return unstakeAndWithdraw(conicLpAmount, minUnderlyingReceived, msg.sender);
    }

    function withdraw(
        uint256 conicLpAmount,
        uint256 minUnderlyingReceived
    ) public override returns (uint256) {
        return withdraw(conicLpAmount, minUnderlyingReceived, msg.sender);
    }

    /// @notice Withdraw underlying
    /// @param conicLpAmount Amount of LP tokens to burn
    /// @param minUnderlyingReceived Minimum amount of underlying to redeem
    /// This should always be set to a reasonable value (e.g. 2%), otherwise
    /// the user withdrawing could be forced into paying a withdrawal penalty fee
    /// by another user
    /// @return uint256 Total underlying withdrawn
    function withdraw(
        uint256 conicLpAmount,
        uint256 minUnderlyingReceived,
        address to
    ) public override returns (uint256) {
        runSanityChecks();

        // Preparing Withdrawals
        require(lpToken.balanceOf(msg.sender) >= conicLpAmount, "insufficient balance");
        uint256 underlyingBalanceBefore_ = underlying.balanceOf(address(this));

        // Processing Withdrawals
        (
            uint256 totalUnderlying_,
            uint256 allocatedUnderlying_,
            uint256[] memory allocatedPerPool
        ) = getTotalAndPerPoolUnderlying();
        uint256 underlyingToReceive_ = conicLpAmount.mulDown(_exchangeRate(totalUnderlying_));
        {
            if (underlyingBalanceBefore_ < underlyingToReceive_) {
                uint256 underlyingToWithdraw_ = underlyingToReceive_ - underlyingBalanceBefore_;
                _withdrawFromCurve(allocatedUnderlying_, allocatedPerPool, underlyingToWithdraw_);
            }
        }

        // Sending Underlying and burning LP Tokens
        uint256 underlyingWithdrawn_ = _min(
            underlying.balanceOf(address(this)),
            underlyingToReceive_
        );
        require(underlyingWithdrawn_ >= minUnderlyingReceived, "too much slippage");
        lpToken.burn(msg.sender, conicLpAmount, msg.sender);
        underlying.safeTransfer(to, underlyingWithdrawn_);

        _cachedTotalUnderlying = totalUnderlying_ - underlyingWithdrawn_;
        _cacheUpdatedTimestamp = block.timestamp;

        // state has already been updated, so no need to worry about re-entrancy
        if (to.supportsInterface(type(IWithdrawalProcessor).interfaceId)) {
            IWithdrawalProcessor(to).processWithdrawal(msg.sender, underlyingWithdrawn_);
        }

        emit Withdraw(msg.sender, underlyingWithdrawn_);
        return underlyingWithdrawn_;
    }

    function _withdrawFromCurve(
        uint256 totalUnderlying_,
        uint256[] memory allocatedPerPool,
        uint256 amount_
    ) internal {
        uint256 withdrawalsRemaining_ = amount_;
        uint256 totalAfterWithdrawal_ = totalUnderlying_ - amount_;

        // NOTE: avoid modifying `allocatedPerPool`
        uint256[] memory allocatedPerPoolCopy = allocatedPerPool.copy();

        while (withdrawalsRemaining_ > 0) {
            (uint256 poolIndex_, uint256 maxWithdrawal_) = weightManager.getWithdrawPool(
                totalAfterWithdrawal_,
                allocatedPerPoolCopy,
                _getMaxDeviation()
            );
            address pool_ = weightManager.getPoolAtIndex(poolIndex_);

            // Withdrawing from least balanced pool
            uint256 toWithdraw_ = _min(withdrawalsRemaining_, maxWithdrawal_);

            address poolAdapter = address(controller.poolAdapterFor(pool_));
            poolAdapter.functionDelegateCall(
                abi.encodeWithSignature(
                    "withdraw(address,address,uint256)",
                    pool_,
                    underlying,
                    toWithdraw_
                )
            );
            withdrawalsRemaining_ -= toWithdraw_;
            allocatedPerPoolCopy[poolIndex_] -= toWithdraw_;
        }
    }

    function allPools() external view override returns (address[] memory) {
        return weightManager.allPools();
    }

    function poolsCount() external view override returns (uint256) {
        return weightManager.poolsCount();
    }

    function getPoolAtIndex(uint256 _index) external view override returns (address) {
        return weightManager.getPoolAtIndex(_index);
    }

    function isRegisteredPool(address _pool) external view returns (bool) {
        return weightManager.isRegisteredPool(_pool);
    }

    // Controller and Admin functions

    function addPool(address _pool) external override onlyOwner {
        weightManager.addPool(_pool);
        address booster = controller.convexBooster();
        address lpToken_ = controller.poolAdapterFor(_pool).lpToken(_pool);
        IERC20(lpToken_).safeApprove(booster, type(uint256).max);
    }

    function removePool(address _pool) external override onlyOwner {
        weightManager.removePool(_pool);
        address booster = controller.convexBooster();
        address lpToken_ = controller.poolAdapterFor(_pool).lpToken(_pool);
        IERC20(lpToken_).safeApprove(booster, 0);
    }

    function updateWeights(PoolWeight[] memory poolWeights) external onlyController {
        runSanityChecks();
        weightManager.updateWeights(poolWeights);

        (
            uint256 totalUnderlying_,
            uint256 totalAllocated,
            uint256[] memory allocatedPerPool
        ) = getTotalAndPerPoolUnderlying();

        uint256 totalDeviation = weightManager.computeTotalDeviation(
            totalUnderlying_,
            allocatedPerPool
        );
        totalDeviationAfterWeightUpdate = totalDeviation;
        rebalancingRewardActive =
            rebalancingRewardsEnabled &&
            !_isBalanced(allocatedPerPool, totalAllocated);
        rebalancingRewardsFactor = ScaledMath.ONE;
        rebalancingRewardsActivatedAt = uint64(block.timestamp);

        // Updating price cache for all pools
        // Used for seeing if a pool has depegged
        _updatePriceCache();
    }

    function shutdownPool() external override onlyController {
        require(!isShutdown, "pool already shut down");
        isShutdown = true;
        emit Shutdown();
    }

    function updateDepegThreshold(uint256 newDepegThreshold_) external onlyOwner {
        require(newDepegThreshold_ >= _MIN_DEPEG_THRESHOLD, "invalid depeg threshold");
        require(newDepegThreshold_ <= _MAX_DEPEG_THRESHOLD, "invalid depeg threshold");
        require(newDepegThreshold_ != depegThreshold, "same as current");
        depegThreshold = newDepegThreshold_;
        emit DepegThresholdUpdated(newDepegThreshold_);
    }

    /// @notice Called when an underlying of a Curve Pool has depegged and we want to exit the pool.
    /// Will check if a coin has depegged, and will revert if not.
    /// Sets the weight of the Curve Pool to 0, and re-enables CNC rewards for deposits.
    /// @dev Cannot be called if the underlying of this pool itself has depegged.
    /// @param curvePool_ The Curve Pool to handle.
    function handleDepeggedCurvePool(address curvePool_) external override {
        runSanityChecks();

        require(!_isAssetDepegged(address(underlying)), "underlying is depegged");
        require(_isPoolDepegged(curvePool_), "pool is not depegged");

        weightManager.handleDepeggedCurvePool(curvePool_);

        // Updating total deviation
        (
            uint256 totalUnderlying_,
            ,
            uint256[] memory allocatedPerPool
        ) = getTotalAndPerPoolUnderlying();
        uint256 totalDeviation = weightManager.computeTotalDeviation(
            totalUnderlying_,
            allocatedPerPool
        );
        totalDeviationAfterWeightUpdate = totalDeviation;

        if (rebalancingRewardsEnabled) {
            IPoolAdapter poolAdapter = controller.poolAdapterFor(curvePool_);
            uint256 usdValue = poolAdapter.computePoolValueInUSD(address(this), curvePool_);
            if (usdValue > _MAX_USD_VALUE_FOR_REMOVING_POOL) {
                // if the rebalancing rewards were already active
                // we reset the activated at because the rewards factor is now increased
                rebalancingRewardsActivatedAt = uint64(block.timestamp);
                rebalancingRewardsFactor = emergencyRebalancingRewardsFactor;
                rebalancingRewardActive = true;
            }
        }

        emit HandledDepeggedCurvePool(curvePool_);
    }

    /**
     * @notice Allows anyone to set the weight of a Curve pool to 0 if the Convex pool for the
     * associated PID has been shut down. This is a very unlikely outcome and the method does
     * not reenable rebalancing rewards.
     * @param curvePool_ Curve pool for which the Convex PID is invalid (has been shut down)
     */
    function handleInvalidConvexPid(address curvePool_) external override returns (uint256) {
        runSanityChecks();
        uint256 pid = weightManager.handleInvalidConvexPid(curvePool_);
        emit HandledInvalidConvexPid(curvePool_, pid);
        return pid;
    }

    function setMaxIdleCurveLpRatio(uint256 maxIdleCurveLpRatio_) external onlyOwner {
        require(maxIdleCurveLpRatio != maxIdleCurveLpRatio_, "same as current");
        require(maxIdleCurveLpRatio_ <= _IDLE_RATIO_UPPER_BOUND, "ratio exceeds upper bound");
        maxIdleCurveLpRatio = maxIdleCurveLpRatio_;
        emit NewMaxIdleCurveLpRatio(maxIdleCurveLpRatio_);
    }

    function setMaxDeviation(uint256 maxDeviation_) external override onlyOwner {
        require(maxDeviation != maxDeviation_, "same as current");
        require(maxDeviation_ <= _MAX_DEVIATION_UPPER_BOUND, "deviation exceeds upper bound");
        maxDeviation = maxDeviation_;
        emit MaxDeviationUpdated(maxDeviation_);
    }

    function getWeight(address curvePool) external view override returns (uint256) {
        return weightManager.getWeight(curvePool);
    }

    function getWeights() external view override returns (PoolWeight[] memory) {
        return weightManager.getWeights();
    }

    function getAllocatedUnderlying() external view override returns (PoolWithAmount[] memory) {
        address[] memory pools = weightManager.allPools();
        PoolWithAmount[] memory perPoolAllocated = new PoolWithAmount[](pools.length);
        (, , uint256[] memory allocated) = getTotalAndPerPoolUnderlying();

        for (uint256 i; i < perPoolAllocated.length; i++) {
            perPoolAllocated[i] = PoolWithAmount(pools[i], allocated[i]);
        }
        return perPoolAllocated;
    }

    function computeTotalDeviation() external view override returns (uint256) {
        (
            ,
            uint256 allocatedUnderlying_,
            uint256[] memory perPoolUnderlying
        ) = getTotalAndPerPoolUnderlying();
        return weightManager.computeTotalDeviation(allocatedUnderlying_, perPoolUnderlying);
    }

    function cachedTotalUnderlying() public view virtual override returns (uint256) {
        if (block.timestamp > _cacheUpdatedTimestamp + _TOTAL_UNDERLYING_CACHE_EXPIRY) {
            return totalUnderlying();
        }
        return _cachedTotalUnderlying;
    }

    function getTotalAndPerPoolUnderlying()
        public
        view
        returns (
            uint256 totalUnderlying_,
            uint256 totalAllocated_,
            uint256[] memory perPoolUnderlying_
        )
    {
        uint256 underlyingPrice_ = controller.priceOracle().getUSDPrice(address(underlying));
        return _getTotalAndPerPoolUnderlying(underlyingPrice_, IPoolAdapter.PriceMode.Latest);
    }

    function isBalanced() external view override returns (bool) {
        (
            ,
            uint256 allocatedUnderlying_,
            uint256[] memory allocatedPerPool_
        ) = getTotalAndPerPoolUnderlying();
        return _isBalanced(allocatedPerPool_, allocatedUnderlying_);
    }

    function setRebalancingRewardsEnabled(bool enabled) external override onlyOwner {
        require(rebalancingRewardsEnabled != enabled, "same as current");
        rebalancingRewardsEnabled = enabled;
        emit RebalancingRewardsEnabledSet(enabled);
    }

    function setEmergencyRebalancingRewardFactor(uint256 factor_) external onlyOwner {
        require(factor_ >= _MIN_EMERGENCY_REBALANCING_REWARD_FACTOR, "factor below minimum");
        require(factor_ <= _MAX_EMERGENCY_REBALANCING_REWARD_FACTOR, "factor above maximum");
        require(factor_ != emergencyRebalancingRewardsFactor, "same as current");
        emergencyRebalancingRewardsFactor = factor_;
        emit EmergencyRebalancingRewardFactorUpdated(factor_);
    }

    function _updateAdapterCachedPrices() internal {
        address[] memory pools = weightManager.allPools();
        uint256 poolsLength_ = pools.length;
        for (uint256 i; i < poolsLength_; i++) {
            address pool_ = pools[i];
            IPoolAdapter poolAdapter = controller.poolAdapterFor(pool_);
            poolAdapter.updatePriceCache(pool_);
        }
    }

    /**
     * @notice Returns several values related to the Omnipools's underlying assets.
     * @param underlyingPrice_ Price of the underlying asset in USD
     * @return totalUnderlying_ Total underlying value of the Omnipool
     * @return totalAllocated_ Total underlying value of the Omnipool that is allocated to Curve pools
     * @return perPoolUnderlying_ Array of underlying values of the Omnipool that is allocated to each Curve pool
     */
    function _getTotalAndPerPoolUnderlying(
        uint256 underlyingPrice_,
        IPoolAdapter.PriceMode priceMode
    )
        internal
        view
        returns (
            uint256 totalUnderlying_,
            uint256 totalAllocated_,
            uint256[] memory perPoolUnderlying_
        )
    {
        address[] memory pools = weightManager.allPools();
        uint256 poolsLength_ = pools.length;
        perPoolUnderlying_ = new uint256[](poolsLength_);

        for (uint256 i; i < poolsLength_; i++) {
            address pool_ = pools[i];
            uint256 poolUnderlying_ = controller.poolAdapterFor(pool_).computePoolValueInUnderlying(
                address(this),
                pool_,
                address(underlying),
                underlyingPrice_,
                priceMode
            );
            perPoolUnderlying_[i] = poolUnderlying_;
            totalAllocated_ += poolUnderlying_;
        }
        totalUnderlying_ = totalAllocated_ + underlying.balanceOf(address(this));
    }

    function _handleRebalancingRewards(
        address account,
        uint256 allocatedBalanceBefore_,
        uint256[] memory allocatedPerPoolBefore,
        uint256 allocatedBalanceAfter_,
        uint256[] memory allocatedPerPoolAfter
    ) internal {
        if (!rebalancingRewardActive) return;
        uint256 deviationBefore = weightManager.computeTotalDeviation(
            allocatedBalanceBefore_,
            allocatedPerPoolBefore
        );
        uint256 deviationAfter = weightManager.computeTotalDeviation(
            allocatedBalanceAfter_,
            allocatedPerPoolAfter
        );

        controller.inflationManager().handleRebalancingRewards(
            account,
            deviationBefore,
            deviationAfter
        );

        if (_isBalanced(allocatedPerPoolAfter, allocatedBalanceAfter_)) {
            rebalancingRewardActive = false;
        }
    }

    function _min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    function _isBalanced(
        uint256[] memory allocatedPerPool_,
        uint256 totalAllocated_
    ) internal view returns (bool) {
        return weightManager.isBalanced(allocatedPerPool_, totalAllocated_, maxDeviation);
    }

    function getAllUnderlyingCoins() public view returns (address[] memory) {
        address[] memory pools = weightManager.allPools();
        uint256 poolsLength_ = pools.length;
        address[] memory underlyings_ = new address[](0);

        for (uint256 i; i < poolsLength_; i++) {
            address pool_ = pools[i];
            address[] memory coins = controller.poolAdapterFor(pool_).getAllUnderlyingCoins(pool_);
            underlyings_ = underlyings_.concat(coins);
        }
        return underlyings_.removeDuplicates();
    }

    function _isPoolDepegged(address pool_) internal view returns (bool) {
        address[] memory coins = controller.poolAdapterFor(pool_).getAllUnderlyingCoins(pool_);
        for (uint256 i; i < coins.length; i++) {
            address coin = coins[i];
            if (_isAssetDepegged(coin)) return true;
        }
        return false;
    }

    function runSanityChecks() public virtual {}

    function _getMaxDeviation() internal view returns (uint256) {
        return rebalancingRewardActive ? 0 : maxDeviation;
    }

    function _updatePriceCache() internal virtual;

    function _isAssetDepegged(address asset_) internal view virtual returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^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() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "IERC20.sol";
import "IERC20Metadata.sol";
import "Context.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.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead 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, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override 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 default value returned by this function, unless
     * it's overridden.
     *
     * 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 override returns (uint8) {
        return 18;
    }

    /**
     * @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:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, 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}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, 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}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        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) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + 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) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This 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:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, 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:
     *
     * - `account` 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 += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(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);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(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 Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @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 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 {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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://consensys.net/diligence/blog/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.8.0/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");

        (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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableMap.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableMap.js.

pragma solidity ^0.8.0;

import "EnumerableSet.sol";

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * The following map types are supported:
 *
 * - `uint256 -> address` (`UintToAddressMap`) since v3.0.0
 * - `address -> uint256` (`AddressToUintMap`) since v4.6.0
 * - `bytes32 -> bytes32` (`Bytes32ToBytes32Map`) since v4.6.0
 * - `uint256 -> uint256` (`UintToUintMap`) since v4.7.0
 * - `bytes32 -> uint256` (`Bytes32ToUintMap`) since v4.7.0
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableMap, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableMap.
 * ====
 */
library EnumerableMap {
    using EnumerableSet for EnumerableSet.Bytes32Set;

    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct Bytes32ToBytes32Map {
        // Storage of keys
        EnumerableSet.Bytes32Set _keys;
        mapping(bytes32 => bytes32) _values;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(Bytes32ToBytes32Map storage map, bytes32 key, bytes32 value) internal returns (bool) {
        map._values[key] = value;
        return map._keys.add(key);
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns (bool) {
        delete map._values[key];
        return map._keys.remove(key);
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) {
        return map._keys.contains(key);
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function length(Bytes32ToBytes32Map storage map) internal view returns (uint256) {
        return map._keys.length();
    }

    /**
     * @dev Returns the key-value pair stored at position `index` in the map. O(1).
     *
     * Note that there are no guarantees on the ordering of entries inside the
     * array, and it may change when more entries are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32ToBytes32Map storage map, uint256 index) internal view returns (bytes32, bytes32) {
        bytes32 key = map._keys.at(index);
        return (key, map._values[key]);
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool, bytes32) {
        bytes32 value = map._values[key];
        if (value == bytes32(0)) {
            return (contains(map, key), bytes32(0));
        } else {
            return (true, value);
        }
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || contains(map, key), "EnumerableMap: nonexistent key");
        return value;
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(
        Bytes32ToBytes32Map storage map,
        bytes32 key,
        string memory errorMessage
    ) internal view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || contains(map, key), errorMessage);
        return value;
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(Bytes32ToBytes32Map storage map) internal view returns (bytes32[] memory) {
        return map._keys.values();
    }

    // UintToUintMap

    struct UintToUintMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToUintMap storage map, uint256 key, uint256 value) internal returns (bool) {
        return set(map._inner, bytes32(key), bytes32(value));
    }

    /**
     * @dev Removes a value from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToUintMap storage map, uint256 key) internal returns (bool) {
        return remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToUintMap storage map, uint256 key) internal view returns (bool) {
        return contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToUintMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the map. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintToUintMap storage map, uint256 index) internal view returns (uint256, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (uint256(key), uint256(value));
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(UintToUintMap storage map, uint256 key) internal view returns (bool, uint256) {
        (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
        return (success, uint256(value));
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToUintMap storage map, uint256 key) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(key)));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToUintMap storage map, uint256 key, string memory errorMessage) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(key), errorMessage));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(UintToUintMap storage map) internal view returns (uint256[] memory) {
        bytes32[] memory store = keys(map._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
        return remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
        return contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the map. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (uint256(key), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(
        UintToAddressMap storage map,
        uint256 key,
        string memory errorMessage
    ) internal view returns (address) {
        return address(uint160(uint256(get(map._inner, bytes32(key), errorMessage))));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(UintToAddressMap storage map) internal view returns (uint256[] memory) {
        bytes32[] memory store = keys(map._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressToUintMap

    struct AddressToUintMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(AddressToUintMap storage map, address key, uint256 value) internal returns (bool) {
        return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));
    }

    /**
     * @dev Removes a value from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(AddressToUintMap storage map, address key) internal returns (bool) {
        return remove(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(AddressToUintMap storage map, address key) internal view returns (bool) {
        return contains(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(AddressToUintMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the map. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (address(uint160(uint256(key))), uint256(value));
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(AddressToUintMap storage map, address key) internal view returns (bool, uint256) {
        (bool success, bytes32 value) = tryGet(map._inner, bytes32(uint256(uint160(key))));
        return (success, uint256(value));
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(AddressToUintMap storage map, address key) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(uint256(uint160(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(
        AddressToUintMap storage map,
        address key,
        string memory errorMessage
    ) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(uint256(uint160(key))), errorMessage));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(AddressToUintMap storage map) internal view returns (address[] memory) {
        bytes32[] memory store = keys(map._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // Bytes32ToUintMap

    struct Bytes32ToUintMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(Bytes32ToUintMap storage map, bytes32 key, uint256 value) internal returns (bool) {
        return set(map._inner, key, bytes32(value));
    }

    /**
     * @dev Removes a value from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(Bytes32ToUintMap storage map, bytes32 key) internal returns (bool) {
        return remove(map._inner, key);
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool) {
        return contains(map._inner, key);
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(Bytes32ToUintMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the map. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32ToUintMap storage map, uint256 index) internal view returns (bytes32, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (key, uint256(value));
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool, uint256) {
        (bool success, bytes32 value) = tryGet(map._inner, key);
        return (success, uint256(value));
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(Bytes32ToUintMap storage map, bytes32 key) internal view returns (uint256) {
        return uint256(get(map._inner, key));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(
        Bytes32ToUintMap storage map,
        bytes32 key,
        string memory errorMessage
    ) internal view returns (uint256) {
        return uint256(get(map._inner, key, errorMessage));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(Bytes32ToUintMap storage map) internal view returns (bytes32[] memory) {
        bytes32[] memory store = keys(map._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "IERC20.sol";
import "IERC20Permit.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 Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    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'
        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));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/introspection/ERC165Checker.sol)

pragma solidity ^0.8.0;

import "IERC165.sol";

/**
 * @dev Library used to query support of an interface declared via {IERC165}.
 *
 * Note that these functions return the actual result of the query: they do not
 * `revert` if an interface is not supported. It is up to the caller to decide
 * what to do in these cases.
 */
library ERC165Checker {
    // As per the EIP-165 spec, no interface should ever match 0xffffffff
    bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;

    /**
     * @dev Returns true if `account` supports the {IERC165} interface.
     */
    function supportsERC165(address account) internal view returns (bool) {
        // Any contract that implements ERC165 must explicitly indicate support of
        // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
        return
            supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) &&
            !supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
    }

    /**
     * @dev Returns true if `account` supports the interface defined by
     * `interfaceId`. Support for {IERC165} itself is queried automatically.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
        // query support of both ERC165 as per the spec and support of _interfaceId
        return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
    }

    /**
     * @dev Returns a boolean array where each value corresponds to the
     * interfaces passed in and whether they're supported or not. This allows
     * you to batch check interfaces for a contract where your expectation
     * is that some interfaces may not be supported.
     *
     * See {IERC165-supportsInterface}.
     *
     * _Available since v3.4._
     */
    function getSupportedInterfaces(
        address account,
        bytes4[] memory interfaceIds
    ) internal view returns (bool[] memory) {
        // an array of booleans corresponding to interfaceIds and whether they're supported or not
        bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);

        // query support of ERC165 itself
        if (supportsERC165(account)) {
            // query support of each interface in interfaceIds
            for (uint256 i = 0; i < interfaceIds.length; i++) {
                interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
            }
        }

        return interfaceIdsSupported;
    }

    /**
     * @dev Returns true if `account` supports all the interfaces defined in
     * `interfaceIds`. Support for {IERC165} itself is queried automatically.
     *
     * Batch-querying can lead to gas savings by skipping repeated checks for
     * {IERC165} support.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
        // query support of ERC165 itself
        if (!supportsERC165(account)) {
            return false;
        }

        // query support of each interface in interfaceIds
        for (uint256 i = 0; i < interfaceIds.length; i++) {
            if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
                return false;
            }
        }

        // all interfaces supported
        return true;
    }

    /**
     * @notice Query if a contract implements an interface, does not check ERC165 support
     * @param account The address of the contract to query for support of an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @return true if the contract at account indicates support of the interface with
     * identifier interfaceId, false otherwise
     * @dev Assumes that account contains a contract that supports ERC165, otherwise
     * the behavior of this method is undefined. This precondition can be checked
     * with {supportsERC165}.
     *
     * Some precompiled contracts will falsely indicate support for a given interface, so caution
     * should be exercised when using this function.
     *
     * Interface identification is specified in ERC-165.
     */
    function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
        // prepare call
        bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);

        // perform static call
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly {
            success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0x00)
        }

        return success && returnSize >= 0x20 && returnValue > 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "ILpToken.sol";
import "IRewardManager.sol";
import "IOracle.sol";
import "IController.sol";
import "IPausable.sol";
import "IConicPoolWeightManagement.sol";

interface IConicPool is IConicPoolWeightManagement, IPausable {
    event Deposit(
        address indexed sender,
        address indexed receiver,
        uint256 depositedAmount,
        uint256 lpReceived
    );
    event Withdraw(address indexed account, uint256 amount);
    event NewWeight(address indexed curvePool, uint256 newWeight);
    event NewMaxIdleCurveLpRatio(uint256 newRatio);
    event ClaimedRewards(uint256 claimedCrv, uint256 claimedCvx);
    event HandledDepeggedCurvePool(address curvePool_);
    event HandledInvalidConvexPid(address curvePool_, uint256 pid_);
    event CurvePoolAdded(address curvePool_);
    event CurvePoolRemoved(address curvePool_);
    event Shutdown();
    event DepegThresholdUpdated(uint256 newThreshold);
    event MaxDeviationUpdated(uint256 newMaxDeviation);
    event RebalancingRewardsEnabledSet(bool enabled);
    event EmergencyRebalancingRewardFactorUpdated(uint256 factor);

    struct PoolWithAmount {
        address poolAddress;
        uint256 amount;
    }

    function underlying() external view returns (IERC20Metadata);

    function lpToken() external view returns (ILpToken);

    function rewardManager() external view returns (IRewardManager);

    function depegThreshold() external view returns (uint256);

    function maxIdleCurveLpRatio() external view returns (uint256);

    function setMaxIdleCurveLpRatio(uint256 value) external;

    function setMaxDeviation(uint256 maxDeviation_) external;

    function updateDepegThreshold(uint256 value) external;

    function depositFor(
        address _account,
        uint256 _amount,
        uint256 _minLpReceived,
        bool stake
    ) external returns (uint256);

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

    function deposit(
        uint256 _amount,
        uint256 _minLpReceived,
        bool stake
    ) external returns (uint256);

    function exchangeRate() external view returns (uint256);

    function usdExchangeRate() external view returns (uint256);

    function unstakeAndWithdraw(uint256 _amount, uint256 _minAmount) external returns (uint256);

    function unstakeAndWithdraw(
        uint256 _amount,
        uint256 _minAmount,
        address _to
    ) external returns (uint256);

    function withdraw(uint256 _amount, uint256 _minAmount) external returns (uint256);

    function withdraw(uint256 _amount, uint256 _minAmount, address _to) external returns (uint256);

    function getAllocatedUnderlying() external view returns (PoolWithAmount[] memory);

    function rebalancingRewardActive() external view returns (bool);

    function totalDeviationAfterWeightUpdate() external view returns (uint256);

    function computeTotalDeviation() external view returns (uint256);

    /// @notice returns the total amount of funds held by this pool in terms of underlying
    function totalUnderlying() external view returns (uint256);

    function getTotalAndPerPoolUnderlying()
        external
        view
        returns (
            uint256 totalUnderlying_,
            uint256 totalAllocated_,
            uint256[] memory perPoolUnderlying_
        );

    /// @notice same as `totalUnderlying` but returns a cached version
    /// that might be slightly outdated if oracle prices have changed
    /// @dev this is useful in cases where we want to reduce gas usage and do
    /// not need a precise value
    function cachedTotalUnderlying() external view returns (uint256);

    function updateRewardSpendingApproval(address token, bool approved) external;

    function shutdownPool() external;

    function isShutdown() external view returns (bool);

    function isBalanced() external view returns (bool);

    function rebalancingRewardsEnabled() external view returns (bool);

    function setRebalancingRewardsEnabled(bool enabled) external;

    function getAllUnderlyingCoins() external view returns (address[] memory result);

    function rebalancingRewardsFactor() external view returns (uint256);

    function rebalancingRewardsActivatedAt() external view returns (uint64);

    function getWeights() external view returns (PoolWeight[] memory);

    function runSanityChecks() external;
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "IERC20Metadata.sol";

interface ILpToken is IERC20Metadata {
    function minter() external view returns (address);

    function mint(address account, uint256 amount, address ubo) external returns (uint256);

    function burn(address _owner, uint256 _amount, address ubo) external returns (uint256);

    function taint(address from, address to, uint256 amount) external;
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

interface IRewardManager {
    event ClaimedRewards(uint256 claimedCrv, uint256 claimedCvx);
    event SoldRewardTokens(uint256 targetTokenReceived);
    event ExtraRewardAdded(address reward);
    event ExtraRewardRemoved(address reward);
    event ExtraRewardsCurvePoolSet(address extraReward, address curvePool);
    event FeesSet(uint256 feePercentage);
    event FeesEnabled(uint256 feePercentage);
    event EarningsClaimed(
        address indexed claimedBy,
        uint256 cncEarned,
        uint256 crvEarned,
        uint256 cvxEarned
    );

    function accountCheckpoint(address account) external;

    function poolCheckpoint() external returns (bool);

    function addExtraReward(address reward) external returns (bool);

    function addBatchExtraRewards(address[] memory rewards) external;

    function conicPool() external view returns (address);

    function setFeePercentage(uint256 _feePercentage) external;

    function claimableRewards(
        address account
    ) external view returns (uint256 cncRewards, uint256 crvRewards, uint256 cvxRewards);

    function claimEarnings() external returns (uint256, uint256, uint256);

    function claimPoolEarningsAndSellRewardTokens() external;

    function feePercentage() external view returns (uint256);

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

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

interface IOracle {
    event TokenUpdated(address indexed token, address feed, uint256 maxDelay, bool isEthPrice);

    /// @notice returns the price in USD of symbol.
    function getUSDPrice(address token) external view returns (uint256);

    /// @notice returns if the given token is supported for pricing.
    function isTokenSupported(address token) external view returns (bool);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "IConicPoolWeightManagement.sol";
import "IConicPool.sol";
import "IGenericOracle.sol";
import "IInflationManager.sol";
import "ILpTokenStaker.sol";
import "IBonding.sol";
import "IPoolAdapter.sol";
import "IFeeRecipient.sol";
import "ICurveRegistryCache.sol";

interface IController {
    event PoolAdded(address indexed pool);
    event PoolRemoved(address indexed pool);
    event PoolShutdown(address indexed pool);
    event ConvexBoosterSet(address convexBooster);
    event CurveHandlerSet(address curveHandler);
    event ConvexHandlerSet(address convexHandler);
    event CurveRegistryCacheSet(address curveRegistryCache);
    event InflationManagerSet(address inflationManager);
    event BondingSet(address bonding);
    event FeeRecipientSet(address feeRecipient);
    event PriceOracleSet(address priceOracle);
    event WeightUpdateMinDelaySet(uint256 weightUpdateMinDelay);
    event PauseManagerSet(address indexed manager, bool isManager);
    event MultiDepositsWithdrawsWhitelistSet(address pool, bool allowed);
    event MinimumTaintedTransferAmountSet(address indexed token, uint256 amount);
    event DefaultPoolAdapterSet(address poolAdapter);
    event CustomPoolAdapterSet(address indexed pool, address poolAdapter);

    struct WeightUpdate {
        address conicPoolAddress;
        IConicPoolWeightManagement.PoolWeight[] weights;
    }

    function initialize(address _lpTokenStaker) external;

    // inflation manager

    function inflationManager() external view returns (IInflationManager);

    function setInflationManager(address manager) external;

    // views
    function curveRegistryCache() external view returns (ICurveRegistryCache);

    // pool adapter
    function poolAdapterFor(address pool) external view returns (IPoolAdapter);

    function defaultPoolAdapter() external view returns (IPoolAdapter);

    function setDefaultPoolAdapter(address poolAdapter) external;

    function setCustomPoolAdapter(address pool, address poolAdapter) external;

    /// lp token staker
    function switchLpTokenStaker(address _lpTokenStaker) external;

    function lpTokenStaker() external view returns (ILpTokenStaker);

    // bonding
    function bonding() external view returns (IBonding);

    function setBonding(address _bonding) external;

    // fees
    function feeRecipient() external view returns (IFeeRecipient);

    function setFeeRecipient(address _feeRecipient) external;

    // oracle
    function priceOracle() external view returns (IGenericOracle);

    function setPriceOracle(address oracle) external;

    // pool functions

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

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

    function isPool(address poolAddress) external view returns (bool);

    function isActivePool(address poolAddress) external view returns (bool);

    function addPool(address poolAddress) external;

    function shutdownPool(address poolAddress) external;

    function removePool(address poolAddress) external;

    function cncToken() external view returns (address);

    function lastWeightUpdate(address poolAddress) external view returns (uint256);

    function updateWeights(WeightUpdate memory update) external;

    function updateAllWeights(WeightUpdate[] memory weights) external;

    // handler functions

    function convexBooster() external view returns (address);

    function curveHandler() external view returns (address);

    function convexHandler() external view returns (address);

    function setConvexBooster(address _convexBooster) external;

    function setCurveHandler(address _curveHandler) external;

    function setConvexHandler(address _convexHandler) external;

    function setCurveRegistryCache(address curveRegistryCache_) external;

    function setWeightUpdateMinDelay(uint256 delay) external;

    function isPauseManager(address account) external view returns (bool);

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

    function setPauseManager(address account, bool isManager) external;

    // deposit/withdrawal whitelist
    function isAllowedMultipleDepositsWithdraws(address poolAddress) external view returns (bool);

    function setAllowedMultipleDepositsWithdraws(address account, bool allowed) external;

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

    // tainted transfer amount
    function setMinimumTaintedTransferAmount(address token, uint256 amount) external;

    function getMinimumTaintedTransferAmount(address token) external view returns (uint256);

    // constants

    function MAX_WEIGHT_UPDATE_MIN_DELAY() external view returns (uint256);

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

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

interface IConicPoolWeightManagement {
    struct PoolWeight {
        address poolAddress;
        uint256 weight;
    }

    function addPool(address pool) external;

    function removePool(address pool) external;

    function updateWeights(PoolWeight[] memory poolWeights) external;

    function handleDepeggedCurvePool(address curvePool_) external;

    function handleInvalidConvexPid(address pool) external returns (uint256);

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

    function poolsCount() external view returns (uint256);

    function getPoolAtIndex(uint256 _index) external view returns (address);

    function getWeight(address curvePool) external view returns (uint256);

    function getWeights() external view returns (PoolWeight[] memory);

    function isRegisteredPool(address _pool) external view returns (bool);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "IOracle.sol";

interface IGenericOracle is IOracle {
    /// @notice returns the oracle to be used to price `token`
    function getOracle(address token) external view returns (IOracle);

    /// @notice converts the price of an LP token to the given underlying
    function curveLpToUnderlying(
        address curveLpToken,
        address underlying,
        uint256 curveLpAmount
    ) external view returns (uint256);

    /// @notice same as above but avoids fetching the underlying price again
    function curveLpToUnderlying(
        address curveLpToken,
        address underlying,
        uint256 curveLpAmount,
        uint256 underlyingPrice
    ) external view returns (uint256);

    /// @notice converts the price an underlying asset to a given Curve LP token
    function underlyingToCurveLp(
        address underlying,
        address curveLpToken,
        uint256 underlyingAmount
    ) external view returns (uint256);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

interface IInflationManager {
    event TokensClaimed(address indexed pool, uint256 cncAmount);
    event RebalancingRewardHandlerAdded(address indexed pool, address indexed handler);
    event RebalancingRewardHandlerRemoved(address indexed pool, address indexed handler);
    event PoolWeightsUpdated();

    function executeInflationRateUpdate() external;

    function updatePoolWeights() external;

    /// @notice returns the weights of the Conic pools to know how much inflation
    /// each of them will receive, as well as the total amount of USD value in all the pools
    function computePoolWeights()
        external
        view
        returns (address[] memory _pools, uint256[] memory poolWeights, uint256 totalUSDValue);

    function computePoolWeight(
        address pool
    ) external view returns (uint256 poolWeight, uint256 totalUSDValue);

    function currentInflationRate() external view returns (uint256);

    function getCurrentPoolInflationRate(address pool) external view returns (uint256);

    function handleRebalancingRewards(
        address account,
        uint256 deviationBefore,
        uint256 deviationAfter
    ) external;

    function addPoolRebalancingRewardHandler(
        address poolAddress,
        address rebalancingRewardHandler
    ) external;

    function removePoolRebalancingRewardHandler(
        address poolAddress,
        address rebalancingRewardHandler
    ) external;

    function rebalancingRewardHandlers(
        address poolAddress
    ) external view returns (address[] memory);

    function hasPoolRebalancingRewardHandler(
        address poolAddress,
        address handler
    ) external view returns (bool);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

interface ILpTokenStaker {
    event LpTokenStaked(address indexed account, uint256 amount);
    event LpTokenUnstaked(address indexed account, uint256 amount);
    event TokensClaimed(address indexed pool, uint256 cncAmount);
    event Shutdown();

    function stake(uint256 amount, address conicPool) external;

    function unstake(uint256 amount, address conicPool) external;

    function stakeFor(uint256 amount, address conicPool, address account) external;

    function unstakeFor(uint256 amount, address conicPool, address account) external;

    function unstakeFrom(uint256 amount, address account) external;

    function getUserBalanceForPool(
        address conicPool,
        address account
    ) external view returns (uint256);

    function getBalanceForPool(address conicPool) external view returns (uint256);

    function updateBoost(address user) external;

    function claimCNCRewardsForPool(address pool) external;

    function claimableCnc(address pool) external view returns (uint256);

    function checkpoint(address pool) external returns (uint256);

    function shutdown() external;

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

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

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

interface IBonding {
    event CncStartPriceSet(uint256 startPrice);
    event PriceIncreaseFactorSet(uint256 factor);
    event MinBondingAmountSet(uint256 amount);
    event Bonded(
        address indexed account,
        address indexed recipient,
        uint256 lpTokenAmount,
        uint256 cncReceived,
        uint256 lockTime
    );
    event DebtPoolSet(address indexed pool);
    event DebtPoolFeesClaimed(uint256 crvAmount, uint256 cvxAmount, uint256 cncAmount);
    event StreamClaimed(address indexed account, uint256 amount);
    event BondingStarted(uint256 amount, uint256 epochs);
    event RemainingCNCRecovered(uint256 amount);

    function startBonding() external;

    function setCncStartPrice(uint256 _cncStartPrice) external;

    function setCncPriceIncreaseFactor(uint256 _priceIncreaseFactor) external;

    function setMinBondingAmount(uint256 _minBondingAmount) external;

    function setDebtPool(address _debtPool) external;

    function bondCncCrvUsd(
        uint256 lpTokenAmount,
        uint256 minCncReceived,
        uint64 cncLockTime
    ) external returns (uint256);

    function recoverRemainingCNC() external;

    function claimStream() external;

    function claimFeesForDebtPool() external;

    function streamCheckpoint() external;

    function accountCheckpoint(address account) external;

    function computeCurrentCncBondPrice() external view returns (uint256);

    function cncAvailable() external view returns (uint256);

    function cncBondPrice() external view returns (uint256);

    function bondCncCrvUsdFor(
        uint256 lpTokenAmount,
        uint256 minCncReceived,
        uint64 cncLockTime,
        address recipient
    ) external returns (uint256);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

interface IPoolAdapter {
    /// @notice This is to set which LP token price the value computation should use
    /// `Latest` uses a freshly computed price
    /// `Cached` uses the price in cache
    /// `Minimum` uses the minimum of these two
    enum PriceMode {
        Latest,
        Cached,
        Minimum
    }

    /// @notice Deposit `underlyingAmount` of `underlying` into `pool`
    /// @dev This function should be written with the assumption that it will be delegate-called into
    function deposit(address pool, address underlying, uint256 underlyingAmount) external;

    /// @notice Withdraw `underlyingAmount` of `underlying` from `pool`
    /// @dev This function should be written with the assumption that it will be delegate-called into
    function withdraw(address pool, address underlying, uint256 underlyingAmount) external;

    /// @notice Returns the amount of of assets that `conicPool` holds in `pool`, in terms of USD
    function computePoolValueInUSD(
        address conicPool,
        address pool
    ) external view returns (uint256 usdAmount);

    /// @notice Updates the price caches of the given pools
    function updatePriceCache(address pool) external;

    /// @notice Returns the amount of of assets that `conicPool` holds in `pool`, in terms of USD
    /// using the given price mode
    function computePoolValueInUSD(
        address conicPool,
        address pool,
        PriceMode priceMode
    ) external view returns (uint256 usdAmount);

    /// @notice Returns the amount of of assets that `conicPool` holds in `pool`, in terms of underlying
    function computePoolValueInUnderlying(
        address conicPool,
        address pool,
        address underlying,
        uint256 underlyingPrice
    ) external view returns (uint256 underlyingAmount);

    /// @notice Returns the amount of of assets that `conicPool` holds in `pool`, in terms of underlying
    /// using the given price mode
    function computePoolValueInUnderlying(
        address conicPool,
        address pool,
        address underlying,
        uint256 underlyingPrice,
        PriceMode priceMode
    ) external view returns (uint256 underlyingAmount);

    /// @notice Claim earnings of `conicPool` from `pool`
    function claimEarnings(address conicPool, address pool) external;

    /// @notice Returns the LP token of a given `pool`
    function lpToken(address pool) external view returns (address);

    /// @notice Returns true if `pool` supports `asset`
    function supportsAsset(address pool, address asset) external view returns (bool);

    /// @notice Returns the amount of CRV earned by `pool` on Convex
    function getCRVEarnedOnConvex(
        address account,
        address curvePool
    ) external view returns (uint256);

    /// @notice Executes a sanity check, e.g. checking for reentrancy
    function executeSanityCheck(address pool) external;

    /// @notice returns all the underlying coins of the pool
    function getAllUnderlyingCoins(address pool) external view returns (address[] memory);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

interface IFeeRecipient {
    event FeesReceived(address indexed sender, uint256 crvAmount, uint256 cvxAmount);

    function receiveFees(uint256 amountCrv, uint256 amountCvx) external;
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "IBooster.sol";
import "CurvePoolUtils.sol";

interface ICurveRegistryCache {
    event PoolInitialized(address indexed pool, uint256 indexed pid);

    function BOOSTER() external view returns (IBooster);

    function initPool(address pool_) external;

    function initPool(address pool_, uint256 pid_) external;

    function lpToken(address pool_) external view returns (address);

    function assetType(address pool_) external view returns (CurvePoolUtils.AssetType);

    function isRegistered(address pool_) external view returns (bool);

    function hasCoinDirectly(address pool_, address coin_) external view returns (bool);

    function hasCoinAnywhere(address pool_, address coin_) external view returns (bool);

    function basePool(address pool_) external view returns (address);

    function coinIndex(address pool_, address coin_) external view returns (int128);

    function nCoins(address pool_) external view returns (uint256);

    function coinIndices(
        address pool_,
        address from_,
        address to_
    ) external view returns (int128, int128, bool);

    function decimals(address pool_) external view returns (uint256[] memory);

    function interfaceVersion(address pool_) external view returns (uint256);

    function poolFromLpToken(address lpToken_) external view returns (address);

    function coins(address pool_) external view returns (address[] memory);

    function getPid(address _pool) external view returns (uint256);

    function getRewardPool(address _pool) external view returns (address);

    function isShutdownPid(uint256 pid_) external view returns (bool);

    /// @notice this returns the underlying coins of a pool, including the underlying of the base pool
    /// if the given pool is a meta pool
    /// This does not return the LP token of the base pool as an underlying
    /// e.g. if the pool is 3CrvFrax, this will return FRAX, DAI, USDC, USDT
    function getAllUnderlyingCoins(address pool) external view returns (address[] memory);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

interface IBooster {
    function poolInfo(
        uint256 pid
    )
        external
        view
        returns (
            address lpToken,
            address token,
            address gauge,
            address crvRewards,
            address stash,
            bool shutdown
        );

    function poolLength() external view returns (uint256);

    function deposit(uint256 _pid, uint256 _amount, bool _stake) external returns (bool);

    function withdraw(uint256 _pid, uint256 _amount) external returns (bool);

    function withdrawAll(uint256 _pid) external returns (bool);

    function depositAll(uint256 _pid, bool _stake) external returns (bool);

    function earmarkRewards(uint256 _pid) external returns (bool);

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

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "ICurvePoolV2.sol";
import "ICurvePoolV1.sol";
import "ScaledMath.sol";

library CurvePoolUtils {
    using ScaledMath for uint256;

    error NotWithinThreshold(address pool, uint256 assetA, uint256 assetB);

    /// @dev by default, allow for 30 bps deviation regardless of pool fees
    uint256 internal constant _DEFAULT_IMBALANCE_BUFFER = 30e14;

    /// @dev Curve scales the `fee` by 1e10
    uint8 internal constant _CURVE_POOL_FEE_DECIMALS = 10;

    /// @dev allow imbalance to be buffer + 3x the fee, e.g. if fee is 3.6 bps and buffer is 30 bps, allow 40.8 bps
    uint256 internal constant _FEE_IMBALANCE_MULTIPLIER = 3;

    enum AssetType {
        USD,
        ETH,
        BTC,
        OTHER,
        CRYPTO
    }

    struct PoolMeta {
        address pool;
        uint256 numberOfCoins;
        AssetType assetType;
        uint256[] decimals;
        uint256[] prices;
        uint256[] imbalanceBuffers;
    }

    function ensurePoolBalanced(PoolMeta memory poolMeta) internal view {
        uint256 poolFee = ICurvePoolV1(poolMeta.pool).fee().convertScale(
            _CURVE_POOL_FEE_DECIMALS,
            18
        );

        for (uint256 i = 0; i < poolMeta.numberOfCoins - 1; i++) {
            uint256 fromDecimals = poolMeta.decimals[i];
            uint256 fromBalance = 10 ** fromDecimals;
            uint256 fromPrice = poolMeta.prices[i];

            for (uint256 j = i + 1; j < poolMeta.numberOfCoins; j++) {
                uint256 toDecimals = poolMeta.decimals[j];
                uint256 toPrice = poolMeta.prices[j];
                uint256 toExpectedUnscaled = (fromBalance * fromPrice) / toPrice;
                uint256 toExpected = toExpectedUnscaled.convertScale(
                    uint8(fromDecimals),
                    uint8(toDecimals)
                );

                uint256 toActual;

                if (poolMeta.assetType == AssetType.CRYPTO) {
                    // Handling crypto pools
                    toActual = ICurvePoolV2(poolMeta.pool).get_dy(i, j, fromBalance);
                } else {
                    // Handling other pools
                    toActual = ICurvePoolV1(poolMeta.pool).get_dy(
                        int128(uint128(i)),
                        int128(uint128(j)),
                        fromBalance
                    );
                }
                uint256 _maxImbalanceBuffer = poolMeta.imbalanceBuffers[i].max(
                    poolMeta.imbalanceBuffers[j]
                );

                if (!_isWithinThreshold(toExpected, toActual, poolFee, _maxImbalanceBuffer))
                    revert NotWithinThreshold(poolMeta.pool, i, j);
            }
        }
    }

    function _isWithinThreshold(
        uint256 a,
        uint256 b,
        uint256 poolFee,
        uint256 imbalanceBuffer
    ) internal pure returns (bool) {
        if (imbalanceBuffer == 0) imbalanceBuffer = _DEFAULT_IMBALANCE_BUFFER;
        uint256 imbalanceTreshold = imbalanceBuffer + poolFee * _FEE_IMBALANCE_MULTIPLIER;
        if (a > b) return (a - b).divDown(a) <= imbalanceTreshold;
        return (b - a).divDown(b) <= imbalanceTreshold;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

interface ICurvePoolV2 {
    function token() external view returns (address);

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

    function factory() external view returns (address);

    function exchange(
        uint256 i,
        uint256 j,
        uint256 dx,
        uint256 min_dy,
        bool use_eth,
        address receiver
    ) external returns (uint256);

    function exchange_underlying(
        uint256 i,
        uint256 j,
        uint256 dx,
        uint256 min_dy,
        address receiver
    ) external returns (uint256);

    function add_liquidity(
        uint256[2] memory amounts,
        uint256 min_mint_amount,
        bool use_eth,
        address receiver
    ) external returns (uint256);

    function add_liquidity(
        uint256[2] memory amounts,
        uint256 min_mint_amount
    ) external returns (uint256);

    function add_liquidity(
        uint256[3] memory amounts,
        uint256 min_mint_amount,
        bool use_eth,
        address receiver
    ) external returns (uint256);

    function add_liquidity(
        uint256[3] memory amounts,
        uint256 min_mint_amount
    ) external returns (uint256);

    function remove_liquidity(
        uint256 _amount,
        uint256[2] memory min_amounts,
        bool use_eth,
        address receiver
    ) external;

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

    function remove_liquidity(
        uint256 _amount,
        uint256[3] memory min_amounts,
        bool use_eth,
        address receiver
    ) external;

    function remove_liquidity(uint256 _amount, uint256[3] memory min_amounts) external;

    function remove_liquidity_one_coin(
        uint256 token_amount,
        uint256 i,
        uint256 min_amount,
        bool use_eth,
        address receiver
    ) external returns (uint256);

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

    function calc_token_amount(uint256[] memory amounts) external view returns (uint256);

    function calc_withdraw_one_coin(
        uint256 token_amount,
        uint256 i
    ) external view returns (uint256);

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

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

interface ICurvePoolV1 {
    function get_virtual_price() external view returns (uint256);

    function add_liquidity(uint256[8] calldata amounts, uint256 min_mint_amount) external;

    function add_liquidity(uint256[7] calldata amounts, uint256 min_mint_amount) external;

    function add_liquidity(uint256[6] calldata amounts, uint256 min_mint_amount) external;

    function add_liquidity(uint256[5] calldata amounts, uint256 min_mint_amount) external;

    function add_liquidity(uint256[4] calldata amounts, uint256 min_mint_amount) external;

    function add_liquidity(uint256[3] calldata amounts, uint256 min_mint_amount) external;

    function add_liquidity(uint256[2] calldata amounts, uint256 min_mint_amount) external;

    function remove_liquidity_imbalance(
        uint256[4] calldata amounts,
        uint256 max_burn_amount
    ) external;

    function remove_liquidity_imbalance(
        uint256[3] calldata amounts,
        uint256 max_burn_amount
    ) external;

    function remove_liquidity_imbalance(
        uint256[2] calldata amounts,
        uint256 max_burn_amount
    ) external;

    function lp_token() external view returns (address);

    function A_PRECISION() external view returns (uint256);

    function A_precise() external view returns (uint256);

    function remove_liquidity(uint256 _amount, uint256[3] calldata min_amounts) external;

    function exchange(
        int128 from,
        int128 to,
        uint256 _from_amount,
        uint256 _min_to_amount
    ) external;

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

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

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

    function calc_token_amount(
        uint256[4] calldata amounts,
        bool deposit
    ) external view returns (uint256);

    function calc_token_amount(
        uint256[3] calldata amounts,
        bool deposit
    ) external view returns (uint256);

    function calc_token_amount(
        uint256[2] calldata amounts,
        bool deposit
    ) external view 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;

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

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

library ScaledMath {
    uint256 internal constant DECIMALS = 18;
    uint256 internal constant ONE = 10 ** DECIMALS;

    function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
        return (a * b) / ONE;
    }

    function mulDown(uint256 a, uint256 b, uint256 decimals) internal pure returns (uint256) {
        return (a * b) / (10 ** decimals);
    }

    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
        return (a * ONE) / b;
    }

    function divDown(uint256 a, uint256 b, uint256 decimals) internal pure returns (uint256) {
        return (a * 10 ** decimals) / b;
    }

    function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        return ((a * ONE) - 1) / b + 1;
    }

    function mulDown(int256 a, int256 b) internal pure returns (int256) {
        return (a * b) / int256(ONE);
    }

    function mulDownUint128(uint128 a, uint128 b) internal pure returns (uint128) {
        return (a * b) / uint128(ONE);
    }

    function mulDown(int256 a, int256 b, uint256 decimals) internal pure returns (int256) {
        return (a * b) / int256(10 ** decimals);
    }

    function divDown(int256 a, int256 b) internal pure returns (int256) {
        return (a * int256(ONE)) / b;
    }

    function divDownUint128(uint128 a, uint128 b) internal pure returns (uint128) {
        return (a * uint128(ONE)) / b;
    }

    function divDown(int256 a, int256 b, uint256 decimals) internal pure returns (int256) {
        return (a * int256(10 ** decimals)) / b;
    }

    function convertScale(
        uint256 a,
        uint8 fromDecimals,
        uint8 toDecimals
    ) internal pure returns (uint256) {
        if (fromDecimals == toDecimals) return a;
        if (fromDecimals > toDecimals) return downscale(a, fromDecimals, toDecimals);
        return upscale(a, fromDecimals, toDecimals);
    }

    function convertScale(
        int256 a,
        uint8 fromDecimals,
        uint8 toDecimals
    ) internal pure returns (int256) {
        if (fromDecimals == toDecimals) return a;
        if (fromDecimals > toDecimals) return downscale(a, fromDecimals, toDecimals);
        return upscale(a, fromDecimals, toDecimals);
    }

    function upscale(
        uint256 a,
        uint8 fromDecimals,
        uint8 toDecimals
    ) internal pure returns (uint256) {
        return a * (10 ** (toDecimals - fromDecimals));
    }

    function downscale(
        uint256 a,
        uint8 fromDecimals,
        uint8 toDecimals
    ) internal pure returns (uint256) {
        return a / (10 ** (fromDecimals - toDecimals));
    }

    function upscale(
        int256 a,
        uint8 fromDecimals,
        uint8 toDecimals
    ) internal pure returns (int256) {
        return a * int256(10 ** (toDecimals - fromDecimals));
    }

    function downscale(
        int256 a,
        uint8 fromDecimals,
        uint8 toDecimals
    ) internal pure returns (int256) {
        return a / int256(10 ** (fromDecimals - toDecimals));
    }

    function intPow(uint256 a, uint256 n) internal pure returns (uint256) {
        uint256 result = ONE;
        for (uint256 i; i < n; ) {
            result = mulDown(result, a);
            unchecked {
                ++i;
            }
        }
        return result;
    }

    function absSub(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            return a >= b ? a - b : b - a;
        }
    }

    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a <= b ? a : b;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "Ownable.sol";

import "IController.sol";

interface IPausable {
    event Paused(uint256 pausedUntil);
    event PauseDurationSet(uint256 pauseDuration);

    function controller() external view returns (IController);

    function pausedUntil() external view returns (uint256);

    function pauseDuration() external view returns (uint256);

    function isPaused() external view returns (bool);

    function setPauseDuration(uint256 _pauseDuration) external;

    function pause() external;
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

interface IWithdrawalProcessor {
    function processWithdrawal(address account, uint256 underlyingAmount) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

interface IBaseRewardPool {
    function stakeFor(address, uint256) external;

    function stake(uint256) external;

    function stakeAll() external returns (bool);

    function withdraw(uint256 amount, bool claim) external returns (bool);

    function withdrawAndUnwrap(uint256 amount, bool claim) external returns (bool);

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

    function getReward() external;

    function getReward(address _account, bool _claimExtras) external;

    function extraRewardsLength() external view returns (uint256);

    function extraRewards(uint256 _pid) external view returns (address);

    function rewardToken() external view returns (address);

    function balanceOf(address account) external view returns (uint256);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "ERC20.sol";
import "SafeERC20.sol";
import "IController.sol";
import "ILpToken.sol";

contract LpToken is ILpToken, ERC20 {
    IController public immutable controller;

    address public immutable override minter;

    modifier onlyMinter() {
        require(msg.sender == minter, "not authorized");
        _;
    }

    mapping(address => uint256) internal _lastEvent;

    uint8 private __decimals;

    constructor(
        address _controller,
        address _minter,
        uint8 _decimals,
        string memory name_,
        string memory symbol_
    ) ERC20(name_, symbol_) {
        controller = IController(_controller);
        minter = _minter;
        __decimals = _decimals;
    }

    function decimals() public view virtual override(ERC20, IERC20Metadata) returns (uint8) {
        return __decimals;
    }

    function mint(
        address _account,
        uint256 _amount,
        address ubo
    ) external override onlyMinter returns (uint256) {
        _ensureSingleEvent(ubo, _amount);
        _mint(_account, _amount);
        return _amount;
    }

    function burn(
        address _owner,
        uint256 _amount,
        address ubo
    ) external override onlyMinter returns (uint256) {
        _ensureSingleEvent(ubo, _amount);
        _burn(_owner, _amount);
        return _amount;
    }

    function taint(address from, address to, uint256 amount) external {
        require(msg.sender == address(controller.lpTokenStaker()), "not authorized");
        _taint(from, to, amount);
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount) internal override {
        // mint/burn are handled in their respective functions
        if (from == address(0) || to == address(0)) return;

        // lpTokenStaker calls `taint` as needed
        address lpTokenStaker = address(controller.lpTokenStaker());
        if (from == lpTokenStaker || to == lpTokenStaker) return;

        // taint any other type of transfer
        _taint(from, to, amount);
    }

    function _ensureSingleEvent(address ubo, uint256 amount) internal {
        if (
            !controller.isAllowedMultipleDepositsWithdraws(ubo) &&
            amount > controller.getMinimumTaintedTransferAmount(address(this))
        ) {
            require(_lastEvent[ubo] != block.number, "cannot mint/burn twice in a block");
            _lastEvent[ubo] = block.number;
        }
    }

    function _taint(address from, address to, uint256 amount) internal {
        if (
            from != to &&
            _lastEvent[from] == block.number &&
            amount > controller.getMinimumTaintedTransferAmount(address(this))
        ) {
            _lastEvent[to] = block.number;
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "Ownable.sol";

import "IController.sol";
import "IPausable.sol";

abstract contract Pausable is Ownable, IPausable {
    uint256 internal constant _MIN_PAUSE_DURATION = 1 hours;
    uint256 internal constant _MAX_PAUSE_DURATION = 3 days;
    uint256 internal constant _INITIAL_PAUSE_DURATION = 8 hours;

    uint256 public pausedUntil;
    uint256 public pauseDuration;

    IController public immutable controller;

    modifier notPaused() {
        require(!isPaused(), "paused");
        _;
    }

    constructor(IController _controller) {
        controller = _controller;
        pauseDuration = _INITIAL_PAUSE_DURATION;
    }

    function setPauseDuration(uint256 _pauseDuration) external onlyOwner {
        require(_pauseDuration >= _MIN_PAUSE_DURATION, "pause duration too short");
        require(_pauseDuration <= _MAX_PAUSE_DURATION, "pause duration too long");
        pauseDuration = _pauseDuration;
        emit PauseDurationSet(pauseDuration);
    }

    function pause() external {
        require(controller.isPauseManager(msg.sender), "not pause manager");
        pausedUntil = block.timestamp + pauseDuration;
        emit Paused(pausedUntil);
    }

    function isPaused() public view override returns (bool) {
        return pausedUntil >= block.timestamp;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "EnumerableSet.sol";
import "EnumerableMap.sol";
import "SafeERC20.sol";

import "IConicPool.sol";
import "IConicPoolWeightManager.sol";

import "ScaledMath.sol";

contract ConicPoolWeightManager is IConicPoolWeightManager {
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableMap for EnumerableMap.AddressToUintMap;
    using ScaledMath for uint256;
    using SafeERC20 for IERC20;

    event CurvePoolAdded(address curvePool_);
    event CurvePoolRemoved(address curvePool_);
    event NewWeight(address indexed curvePool, uint256 newWeight);

    uint256 internal constant _MAX_USD_VALUE_FOR_REMOVING_POOL = 100e18;
    uint256 internal constant _MAX_CURVE_POOLS = 10;

    IConicPool public immutable conicPool;
    IController public immutable controller;
    IERC20Metadata public immutable underlying;

    EnumerableSet.AddressSet internal _pools;
    EnumerableMap.AddressToUintMap internal weights; // liquidity allocation weights

    modifier onlyController() {
        require(msg.sender == address(controller), "not authorized");
        _;
    }

    modifier onlyConicPool() {
        require(msg.sender == address(conicPool), "not authorized");
        _;
    }

    constructor(IController _controller, IERC20Metadata _underlying) {
        conicPool = IConicPool(msg.sender);
        controller = _controller;
        underlying = _underlying;
    }

    function addPool(address _pool) external onlyConicPool {
        require(_pools.length() < _MAX_CURVE_POOLS, "max pools reached");
        require(!_pools.contains(_pool), "pool already added");
        IPoolAdapter poolAdapter = controller.poolAdapterFor(_pool);
        bool supported_ = poolAdapter.supportsAsset(_pool, address(underlying));
        require(supported_, "coin not in pool");
        address lpToken_ = poolAdapter.lpToken(_pool);
        require(controller.priceOracle().isTokenSupported(lpToken_), "cannot price LP Token");

        if (!weights.contains(_pool)) weights.set(_pool, 0);
        require(_pools.add(_pool), "failed to add pool");
        emit CurvePoolAdded(_pool);
    }

    // This requires that the weight of the pool is first set to 0
    function removePool(address _pool) external onlyConicPool {
        require(_pools.contains(_pool), "pool not added");
        require(_pools.length() > 1, "cannot remove last pool");
        IPoolAdapter poolAdapter = controller.poolAdapterFor(_pool);
        uint256 usdValue = poolAdapter.computePoolValueInUSD(address(conicPool), _pool);
        require(usdValue < _MAX_USD_VALUE_FOR_REMOVING_POOL, "pool has allocated funds");
        uint256 weight = weights.get(_pool);
        require(weight == 0, "pool has weight set");
        require(_pools.remove(_pool), "pool not removed");
        require(weights.remove(_pool), "weight not removed");
        emit CurvePoolRemoved(_pool);
    }

    function updateWeights(PoolWeight[] memory poolWeights) external onlyConicPool {
        require(poolWeights.length == _pools.length(), "invalid pool weights");
        uint256 total;

        address previousPool;
        for (uint256 i; i < poolWeights.length; i++) {
            address pool_ = poolWeights[i].poolAddress;
            require(pool_ > previousPool, "pools not sorted");
            require(isRegisteredPool(pool_), "pool is not registered");
            uint256 newWeight = poolWeights[i].weight;
            weights.set(pool_, newWeight);
            emit NewWeight(pool_, newWeight);
            total += newWeight;
            previousPool = pool_;
        }

        require(total == ScaledMath.ONE, "weights do not sum to 1");
    }

    function handleDepeggedCurvePool(address curvePool_) external onlyConicPool {
        // Validation
        require(isRegisteredPool(curvePool_), "pool is not registered");
        require(weights.get(curvePool_) != 0, "pool weight already 0");

        // Set target curve pool weight to 0
        // Scale up other weights to compensate
        _setWeightToZero(curvePool_);
    }

    function handleInvalidConvexPid(address curvePool_) external onlyConicPool returns (uint256) {
        require(isRegisteredPool(curvePool_), "curve pool not registered");
        ICurveRegistryCache registryCache_ = controller.curveRegistryCache();
        uint256 pid = registryCache_.getPid(curvePool_);
        require(registryCache_.isShutdownPid(pid), "convex pool pid is not shut down");
        _setWeightToZero(curvePool_);
        return pid;
    }

    function getDepositPool(
        uint256 totalUnderlying_,
        uint256[] memory allocatedPerPool,
        uint256 maxDeviation
    ) external view returns (uint256 poolIndex, uint256 maxDepositAmount) {
        uint256 poolsCount_ = allocatedPerPool.length;
        int256 iPoolIndex = -1;
        for (uint256 i; i < poolsCount_; i++) {
            address pool_ = _pools.at(i);
            uint256 allocatedUnderlying_ = allocatedPerPool[i];
            uint256 weight_ = weights.get(pool_);
            uint256 targetAllocation_ = totalUnderlying_.mulDown(weight_);
            if (allocatedUnderlying_ >= targetAllocation_) continue;
            // Compute max balance with deviation
            uint256 weightWithDeviation_ = weight_.mulDown(ScaledMath.ONE + maxDeviation);
            weightWithDeviation_ = weightWithDeviation_ > ScaledMath.ONE
                ? ScaledMath.ONE
                : weightWithDeviation_;
            uint256 maxBalance_ = totalUnderlying_.mulDown(weightWithDeviation_);
            uint256 maxDepositAmount_ = maxBalance_ - allocatedUnderlying_;
            if (maxDepositAmount_ <= maxDepositAmount) continue;
            maxDepositAmount = maxDepositAmount_;
            iPoolIndex = int256(i);
        }
        require(iPoolIndex > -1, "error retrieving deposit pool");
        poolIndex = uint256(iPoolIndex);
    }

    function getWithdrawPool(
        uint256 totalUnderlying_,
        uint256[] memory allocatedPerPool,
        uint256 maxDeviation
    ) external view returns (uint256 withdrawPoolIndex, uint256 maxWithdrawalAmount) {
        uint256 poolsCount_ = allocatedPerPool.length;
        int256 iWithdrawPoolIndex = -1;
        for (uint256 i; i < poolsCount_; i++) {
            address curvePool_ = _pools.at(i);
            uint256 weight_ = weights.get(curvePool_);
            uint256 allocatedUnderlying_ = allocatedPerPool[i];

            // If a pool has a weight of 0,
            // withdraw from it if it has more than the max lp value
            if (weight_ == 0) {
                uint256 price_ = controller.priceOracle().getUSDPrice(address(underlying));
                uint256 allocatedUsd = (price_ * allocatedUnderlying_) /
                    10 ** underlying.decimals();
                if (allocatedUsd >= _MAX_USD_VALUE_FOR_REMOVING_POOL / 2) {
                    return (uint256(i), allocatedUnderlying_);
                }
            }

            uint256 targetAllocation_ = totalUnderlying_.mulDown(weight_);
            if (allocatedUnderlying_ <= targetAllocation_) continue;
            uint256 minBalance_ = targetAllocation_ - targetAllocation_.mulDown(maxDeviation);
            uint256 maxWithdrawalAmount_ = allocatedUnderlying_ - minBalance_;
            if (maxWithdrawalAmount_ <= maxWithdrawalAmount) continue;
            maxWithdrawalAmount = maxWithdrawalAmount_;
            iWithdrawPoolIndex = int256(i);
        }
        require(iWithdrawPoolIndex > -1, "error retrieving withdraw pool");
        withdrawPoolIndex = uint256(iWithdrawPoolIndex);
    }

    function allPools() external view returns (address[] memory) {
        return _pools.values();
    }

    function poolsCount() external view returns (uint256) {
        return _pools.length();
    }

    function getPoolAtIndex(uint256 _index) external view returns (address) {
        return _pools.at(_index);
    }

    function isRegisteredPool(address _pool) public view returns (bool) {
        return _pools.contains(_pool);
    }

    function getWeight(address pool) external view returns (uint256) {
        return weights.get(pool);
    }

    function getWeights() external view returns (IConicPool.PoolWeight[] memory) {
        uint256 length_ = _pools.length();
        IConicPool.PoolWeight[] memory weights_ = new IConicPool.PoolWeight[](length_);
        for (uint256 i; i < length_; i++) {
            (address pool_, uint256 weight_) = weights.at(i);
            weights_[i] = PoolWeight(pool_, weight_);
        }
        return weights_;
    }

    function computeTotalDeviation(
        uint256 allocatedUnderlying_,
        uint256[] memory perPoolAllocations_
    ) external view returns (uint256) {
        uint256 totalDeviation;
        for (uint256 i; i < perPoolAllocations_.length; i++) {
            uint256 weight = weights.get(_pools.at(i));
            uint256 targetAmount = allocatedUnderlying_.mulDown(weight);
            totalDeviation += targetAmount.absSub(perPoolAllocations_[i]);
        }
        return totalDeviation;
    }

    function isBalanced(
        uint256[] memory allocatedPerPool_,
        uint256 totalAllocated_,
        uint256 maxDeviation
    ) external view returns (bool) {
        if (totalAllocated_ == 0) return true;
        for (uint256 i; i < allocatedPerPool_.length; i++) {
            uint256 weight_ = weights.get(_pools.at(i));
            uint256 currentAllocated_ = allocatedPerPool_[i];

            // If a curve pool has a weight of 0,
            if (weight_ == 0) {
                uint256 price_ = controller.priceOracle().getUSDPrice(address(underlying));
                uint256 allocatedUsd_ = (price_ * currentAllocated_) / 10 ** underlying.decimals();
                if (allocatedUsd_ >= _MAX_USD_VALUE_FOR_REMOVING_POOL / 2) {
                    return false;
                }
                continue;
            }

            uint256 targetAmount = totalAllocated_.mulDown(weight_);
            uint256 deviation = targetAmount.absSub(currentAllocated_);
            uint256 deviationRatio = deviation.divDown(targetAmount);

            if (deviationRatio > maxDeviation) return false;
        }
        return true;
    }

    function _setWeightToZero(address zeroedPool) internal {
        uint256 weight_ = weights.get(zeroedPool);
        if (weight_ == 0) return;
        require(weight_ != ScaledMath.ONE, "can't remove last pool");
        uint256 scaleUp_ = ScaledMath.ONE.divDown(ScaledMath.ONE - weights.get(zeroedPool));
        uint256 curvePoolLength_ = _pools.length();

        weights.set(zeroedPool, 0);
        emit NewWeight(zeroedPool, 0);

        address[] memory nonZeroPools = new address[](curvePoolLength_ - 1);
        uint256[] memory nonZeroWeights = new uint256[](curvePoolLength_ - 1);
        uint256 nonZeroPoolsCount;
        for (uint256 i; i < curvePoolLength_; i++) {
            address pool_ = _pools.at(i);
            uint256 currentWeight = weights.get(pool_);
            if (currentWeight == 0) continue;
            nonZeroPools[nonZeroPoolsCount] = pool_;
            nonZeroWeights[nonZeroPoolsCount] = currentWeight;
            nonZeroPoolsCount++;
        }

        uint256 totalWeight;
        for (uint256 i; i < nonZeroPoolsCount; i++) {
            address pool_ = nonZeroPools[i];
            uint256 newWeight_ = nonZeroWeights[i].mulDown(scaleUp_);
            // ensure that the sum of the weights is 1 despite potential rounding errors
            if (i == nonZeroPoolsCount - 1) {
                newWeight_ = ScaledMath.ONE - totalWeight;
            }
            totalWeight += newWeight_;
            weights.set(pool_, newWeight_);
            emit NewWeight(pool_, newWeight_);
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

import "IConicPoolWeightManagement.sol";

interface IConicPoolWeightManager is IConicPoolWeightManagement {
    function getDepositPool(
        uint256 totalUnderlying_,
        uint256[] memory allocatedPerPool,
        uint256 maxDeviation
    ) external view returns (uint256 poolIndex, uint256 maxDepositAmount);

    function getWithdrawPool(
        uint256 totalUnderlying_,
        uint256[] memory allocatedPerPool,
        uint256 maxDeviation
    ) external view returns (uint256 withdrawPoolIndex, uint256 maxWithdrawalAmount);

    function computeTotalDeviation(
        uint256 allocatedUnderlying_,
        uint256[] memory perPoolAllocations_
    ) external view returns (uint256);

    function isBalanced(
        uint256[] memory allocatedPerPool_,
        uint256 totalAllocated_,
        uint256 maxDeviation
    ) external view returns (bool);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;

library ArrayExtensions {
    function copy(uint256[] memory array) internal pure returns (uint256[] memory) {
        uint256[] memory copy_ = new uint256[](array.length);
        for (uint256 i = 0; i < array.length; i++) {
            copy_[i] = array[i];
        }
        return copy_;
    }

    function concat(
        address[] memory a,
        address[] memory b
    ) internal pure returns (address[] memory result) {
        result = new address[](a.length + b.length);
        for (uint256 i; i < a.length; i++) result[i] = a[i];
        for (uint256 i; i < b.length; i++) result[i + a.length] = b[i];
    }

    function includes(address[] memory array, address element) internal pure returns (bool) {
        return _includes(array, element, array.length);
    }

    function _includes(
        address[] memory array,
        address element,
        uint256 until
    ) internal pure returns (bool) {
        for (uint256 i; i < until; i++) {
            if (array[i] == element) return true;
        }
        return false;
    }

    function removeDuplicates(address[] memory array) internal pure returns (address[] memory) {
        address[] memory unique = new address[](array.length);
        uint256 j;
        for (uint256 i; i < array.length; i++) {
            if (!_includes(unique, array[i], j)) {
                unique[j++] = array[i];
            }
        }
        return trim(unique, j);
    }

    function trim(
        address[] memory array,
        uint256 length
    ) internal pure returns (address[] memory trimmed) {
        trimmed = new address[](length);
        for (uint256 i; i < length; i++) trimmed[i] = array[i];
    }
}

{
  "evmVersion": "london",
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "libraries": {
    "ConicEthPool.sol": {}
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_underlying","type":"address"},{"internalType":"contract IRewardManager","name":"_rewardManager","type":"address"},{"internalType":"address","name":"_controller","type":"address"},{"internalType":"string","name":"_lpTokenName","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_cvx","type":"address"},{"internalType":"address","name":"_crv","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"claimedCrv","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claimedCvx","type":"uint256"}],"name":"ClaimedRewards","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"curvePool_","type":"address"}],"name":"CurvePoolAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"curvePool_","type":"address"}],"name":"CurvePoolRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newThreshold","type":"uint256"}],"name":"DepegThresholdUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"depositedAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lpReceived","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"factor","type":"uint256"}],"name":"EmergencyRebalancingRewardFactorUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"curvePool_","type":"address"}],"name":"HandledDepeggedCurvePool","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"curvePool_","type":"address"},{"indexed":false,"internalType":"uint256","name":"pid_","type":"uint256"}],"name":"HandledInvalidConvexPid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMaxDeviation","type":"uint256"}],"name":"MaxDeviationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newRatio","type":"uint256"}],"name":"NewMaxIdleCurveLpRatio","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"curvePool","type":"address"},{"indexed":false,"internalType":"uint256","name":"newWeight","type":"uint256"}],"name":"NewWeight","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"pauseDuration","type":"uint256"}],"name":"PauseDurationSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"pausedUntil","type":"uint256"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"RebalancingRewardsEnabledSet","type":"event"},{"anonymous":false,"inputs":[],"name":"Shutdown","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"address","name":"_pool","type":"address"}],"name":"addPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"allPools","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cachedTotalUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"computeTotalDeviation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"contract IController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"depegThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"underlyingAmount","type":"uint256"},{"internalType":"uint256","name":"minLpReceived","type":"uint256"},{"internalType":"bool","name":"stake","type":"bool"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"underlyingAmount","type":"uint256"},{"internalType":"uint256","name":"minLpReceived","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"underlyingAmount","type":"uint256"},{"internalType":"uint256","name":"minLpReceived","type":"uint256"},{"internalType":"bool","name":"stake","type":"bool"}],"name":"depositFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyRebalancingRewardsFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllUnderlyingCoins","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllocatedUnderlying","outputs":[{"components":[{"internalType":"address","name":"poolAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IConicPool.PoolWithAmount[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"getPoolAtIndex","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalAndPerPoolUnderlying","outputs":[{"internalType":"uint256","name":"totalUnderlying_","type":"uint256"},{"internalType":"uint256","name":"totalAllocated_","type":"uint256"},{"internalType":"uint256[]","name":"perPoolUnderlying_","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"curvePool","type":"address"}],"name":"getWeight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWeights","outputs":[{"components":[{"internalType":"address","name":"poolAddress","type":"address"},{"internalType":"uint256","name":"weight","type":"uint256"}],"internalType":"struct IConicPoolWeightManagement.PoolWeight[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"curvePool_","type":"address"}],"name":"handleDepeggedCurvePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"curvePool_","type":"address"}],"name":"handleInvalidConvexPid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isBalanced","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pool","type":"address"}],"name":"isRegisteredPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isShutdown","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpToken","outputs":[{"internalType":"contract ILpToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxDeviation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxIdleCurveLpRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pauseDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pausedUntil","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebalancingRewardActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebalancingRewardsActivatedAt","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebalancingRewardsEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebalancingRewardsFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pool","type":"address"}],"name":"removePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardManager","outputs":[{"internalType":"contract IRewardManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"runSanityChecks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"factor_","type":"uint256"}],"name":"setEmergencyRebalancingRewardFactor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxDeviation_","type":"uint256"}],"name":"setMaxDeviation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxIdleCurveLpRatio_","type":"uint256"}],"name":"setMaxIdleCurveLpRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pauseDuration","type":"uint256"}],"name":"setPauseDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setRebalancingRewardsEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shutdownPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalDeviationAfterWeightUpdate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"contract IERC20Metadata","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"conicLpAmount","type":"uint256"},{"internalType":"uint256","name":"minUnderlyingReceived","type":"uint256"}],"name":"unstakeAndWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"conicLpAmount","type":"uint256"},{"internalType":"uint256","name":"minUnderlyingReceived","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"unstakeAndWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newDepegThreshold_","type":"uint256"}],"name":"updateDepegThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"updateRewardSpendingApproval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"poolAddress","type":"address"},{"internalType":"uint256","name":"weight","type":"uint256"}],"internalType":"struct IConicPoolWeightManagement.PoolWeight[]","name":"poolWeights","type":"tuple[]"}],"name":"updateWeights","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"usdExchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weightManager","outputs":[{"internalType":"contract IConicPoolWeightManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"conicLpAmount","type":"uint256"},{"internalType":"uint256","name":"minUnderlyingReceived","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"conicLpAmount","type":"uint256"},{"internalType":"uint256","name":"minUnderlyingReceived","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

61016060405266470de4df82000060035566b1a2bc2ec50000600455666a94d74f430000600655678ac7230489e80000600a553480156200003f57600080fd5b506040516200a9ba3803806200a9ba83398101604081905262000062916200080c565b86868686868686846200007533620002e6565b6001600160a01b0390811660805261708060025587811690831614801590620000b05750806001600160a01b0316876001600160a01b031614155b8015620000da57506001600160a01b038716739ae380f0272e2162340a5bb646c354271c0f5cfc14155b620001215760405162461bcd60e51b8152602060048201526012602482015271696e76616c696420756e6465726c79696e6760701b60448201526064015b60405180910390fd5b866001600160a01b031660e0816001600160a01b0316815250506000876001600160a01b031663313ce5676040518163ffffffff1660e01b8152600401602060405180830381865afa1580156200017c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620001a29190620008e3565b90508530828787604051620001b7906200070a565b620001c79594939291906200093d565b604051809103906000f080158015620001e4573d6000803e3d6000fd5b506001600160a01b0390811661010052871661012052604051869089906200020c9062000718565b6001600160a01b03928316815291166020820152604001604051809103906000f08015801562000240573d6000803e3d6000fd5b506001600160a01b039081166101405283811660a081905290831660c05262000279908860001962000336602090811b620037ba17901c565b620002a28760001960c0516001600160a01b03166200033660201b620037ba179092919060201c565b620002d1739ae380f0272e2162340a5bb646c354271c0f5cfc8860001962000336602090811b620037ba17901c565b50505050505050505050505050505062000a05565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b801580620003b45750604051636eb1769f60e11b81523060048201526001600160a01b03838116602483015284169063dd62ed3e90604401602060405180830381865afa1580156200038c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620003b2919062000994565b155b620004285760405162461bcd60e51b815260206004820152603660248201527f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60448201527f20746f206e6f6e2d7a65726f20616c6c6f77616e636500000000000000000000606482015260840162000118565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b0390811663095ea7b360e01b17909152620004809185916200048516565b505050565b6000620004e1826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166200056660201b62003902179092919060201c565b905080516000148062000505575080806020019051810190620005059190620009ae565b620004805760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b606482015260840162000118565b60606200057784846000856200057f565b949350505050565b606082471015620005e25760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b606482015260840162000118565b600080866001600160a01b03168587604051620006009190620009d2565b60006040518083038185875af1925050503d80600081146200063f576040519150601f19603f3d011682016040523d82523d6000602084013e62000644565b606091505b509092509050620006588783838762000663565b979650505050505050565b60608315620006d7578251600003620006cf576001600160a01b0385163b620006cf5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640162000118565b508162000577565b620005778383815115620006ee5781518083602001fd5b8060405162461bcd60e51b8152600401620001189190620009f0565b6115178062006c1983390190565b61288a806200813083390190565b6001600160a01b03811681146200073c57600080fd5b50565b634e487b7160e01b600052604160045260246000fd5b60005b838110156200077257818101518382015260200162000758565b50506000910152565b600082601f8301126200078d57600080fd5b81516001600160401b0380821115620007aa57620007aa6200073f565b604051601f8301601f19908116603f01168101908282118183101715620007d557620007d56200073f565b81604052838152866020858801011115620007ef57600080fd5b6200080284602083016020890162000755565b9695505050505050565b600080600080600080600060e0888a0312156200082857600080fd5b8751620008358162000726565b6020890151909750620008488162000726565b60408901519096506200085b8162000726565b60608901519095506001600160401b03808211156200087957600080fd5b620008878b838c016200077b565b955060808a01519150808211156200089e57600080fd5b50620008ad8a828b016200077b565b93505060a0880151620008c08162000726565b60c0890151909250620008d38162000726565b8091505092959891949750929550565b600060208284031215620008f657600080fd5b815160ff811681146200090857600080fd5b9392505050565b600081518084526200092981602086016020860162000755565b601f01601f19169290920160200192915050565b6001600160a01b0386811682528516602082015260ff8416604082015260a06060820181905260009062000974908301856200090f565b82810360808401526200098881856200090f565b98975050505050505050565b600060208284031215620009a757600080fd5b5051919050565b600060208284031215620009c157600080fd5b815180151581146200090857600080fd5b60008251620009e681846020870162000755565b9190910192915050565b6020815260006200090860208301846200090f565b60805160a05160c05160e051610100516101205161014051615fb962000c60600039600081816106f701528181610f6401528181611174015281816112f3015281816117ba0152818161182a01528181611b180152818161246a015281816125ff0152818161278f01528181612876015281816128f401528181612a8501528181612dd501528181612eb10152818161304b015281816130f10152818161348801528181613a0801528181613ac301528181613f7f015281816145d2015281816147ef015281816148b701528181614b6101528181614bdf0152614dec01526000818161048f01528181611a670152611ac701526000818161072b01528181610b4f01528181610ddf015281816121630152818161226201528181612343015261391601526000818161038c015281816107bd01528181610c1f01528181610d0501528181610e620152818161164a015281816116e501528181611f1401528181611fbf015281816120140152818161330301528181613be101528181614118015281816141f10152818161427d01526149dd0152600050506000505060008181610b0c0152818161104d015281816111fa015281816115b3015281816118ec01528181611b7801528181611c1d01528181611e7d015281816121d5015281816124ff0152818161281a015281816129ff01528181612b3701528181612ccb0152818161326c015281816133a0015281816134e80152818161358d01528181613b610152818161409b015281816142eb01528181614493015281816146aa0152818161495d01528181614c700152614e740152615fb96000f3fe6080604052600436106103855760003560e01c80638456cb59116101d1578063c5c63e6511610102578063d6038dc6116100a0578063e2bbb1581161006f578063e2bbb15814610aa4578063f0ea87f614610ac4578063f2fde38b14610ada578063f77c479114610afa57600080fd5b8063d6038dc614610a39578063d914cd4b14610a4e578063da748b1014610a6e578063dddbc04914610a8457600080fd5b8063c9387332116100dc578063c9387332146109d9578063cb03a464146109f9578063ce75040e14610a0e578063d1e6c1e514610a2357600080fd5b8063c5c63e651461098f578063c699e633146109a4578063c70920bc146109c457600080fd5b80639e4865621161016f578063b0a4396811610149578063b0a439681461091d578063b187bd261461093d578063b7b3b8c014610955578063bf86d6901461097557600080fd5b80639e486562146108c8578063a58f1d8e146108e7578063ac6c5251146108fd57600080fd5b80638da5cb5b116101ab5780638da5cb5b146108555780638dbfb25b14610873578063904c9bf0146108935780639765ca15146108a857600080fd5b80638456cb591461080957806386fe9a661461081e5780638c788de01461084057600080fd5b806336797aec116102b6578063441a3e70116102545780636e4f3338116102235780636e4f33381461076d5780636f307dc3146107ab578063715018a6146107df57806383645abf146107f457600080fd5b8063441a3e70146106c55780634af1cd69146106e55780635fcbd2851461071957806365f203551461074d57600080fd5b80633b7d0946116102905780633b7d09461461065a5780633ba0b9a91461067a5780633d4912c31461068f57806343a0d066146106a557600080fd5b806336797aec14610604578063377f7eaa146106245780633a172ddc1461063a57600080fd5b806322acb867116103235780632c3da47d116102fd5780632c3da47d146105765780632cf818011461059657806332f44c42146105c0578063331666fa146105e057600080fd5b806322acb8671461052957806324a71a661461054b5780632a1bab731461056057600080fd5b80630f4ef8a61161035f5780630f4ef8a61461047d5780631010b58c146104c957806310aec8f9146104e95780631280a5b61461050957600080fd5b80630526679c146104125780630ad58d2f1461043b5780630c3457891461045b57600080fd5b3661040d577f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031673c02aaa39b223fe8d0a0e5c4f27ead9083c756cc21461040b5760405162461bcd60e51b815260206004820152600d60248201526c1b9bdd0815d15512081c1bdbdb609a1b60448201526064015b60405180910390fd5b005b600080fd5b34801561041e57600080fd5b5061042860025481565b6040519081526020015b60405180910390f35b34801561044757600080fd5b50610428610456366004615680565b610b2e565b34801561046757600080fd5b50610470610f5e565b60405161043291906156b9565b34801561048957600080fd5b506104b17f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b039091168152602001610432565b3480156104d557600080fd5b506104b16104e4366004615706565b61115b565b3480156104f557600080fd5b5061042861050436600461571f565b6111ed565b34801561051557600080fd5b50610428610524366004615680565b6111f6565b34801561053557600080fd5b5061053e6112ef565b6040516104329190615741565b34801561055757600080fd5b5061042861137c565b34801561056c57600080fd5b5061042860035481565b34801561058257600080fd5b5061040b610591366004615706565b6113a5565b3480156105a257600080fd5b506009546105b09060ff1681565b6040519015158152602001610432565b3480156105cc57600080fd5b5061040b6105db366004615706565b6114a9565b3480156105ec57600080fd5b506105f56115aa565b604051610432939291906157dc565b34801561061057600080fd5b5061040b61061f3660046157fb565b6116d8565b34801561063057600080fd5b50610428600a5481565b34801561064657600080fd5b5061040b610655366004615826565b611a5c565b34801561066657600080fd5b5061040b6106753660046157fb565b611af1565b34801561068657600080fd5b50610428611d0b565b34801561069b57600080fd5b5061042860065481565b3480156106b157600080fd5b506104286106c036600461585f565b611d1d565b3480156106d157600080fd5b506104286106e036600461571f565b611d2b565b3480156106f157600080fd5b506104b17f000000000000000000000000000000000000000000000000000000000000000081565b34801561072557600080fd5b506104b17f000000000000000000000000000000000000000000000000000000000000000081565b34801561075957600080fd5b5061042861076836600461588d565b611d38565b34801561077957600080fd5b50600954610793906201000090046001600160401b031681565b6040516001600160401b039091168152602001610432565b3480156107b757600080fd5b506104b17f000000000000000000000000000000000000000000000000000000000000000081565b3480156107eb57600080fd5b5061040b61242d565b34801561080057600080fd5b50610428612441565b34801561081557600080fd5b5061040b6124ea565b34801561082a57600080fd5b506108336125f9565b60405161043291906158d7565b34801561084c57600080fd5b5061042861278b565b34801561086157600080fd5b506000546001600160a01b03166104b1565b34801561087f57600080fd5b5061040b61088e3660046159bb565b61280f565b34801561089f57600080fd5b5061040b6129fb565b3480156108b457600080fd5b506104286108c33660046157fb565b612da9565b3480156108d457600080fd5b506009546105b090610100900460ff1681565b3480156108f357600080fd5b5061042860045481565b34801561090957600080fd5b506104286109183660046157fb565b612e8f565b34801561092957600080fd5b5061040b610938366004615706565b612f1e565b34801561094957600080fd5b506001544211156105b0565b34801561096157600080fd5b5061040b610970366004615a73565b612fd4565b34801561098157600080fd5b506005546105b09060ff1681565b34801561099b57600080fd5b50610470613047565b3480156109b057600080fd5b506105b06109bf3660046157fb565b6130cf565b3480156109d057600080fd5b5061042861315e565b3480156109e557600080fd5b5061040b6109f4366004615706565b613169565b348015610a0557600080fd5b506105b061324b565b348015610a1a57600080fd5b50610428613267565b348015610a2f57600080fd5b50610428600c5481565b348015610a4557600080fd5b5061040b613395565b348015610a5a57600080fd5b5061040b610a693660046157fb565b613461565b348015610a7a57600080fd5b5061042860015481565b348015610a9057600080fd5b5061040b610a9f366004615706565b61367c565b348015610ab057600080fd5b50610428610abf36600461571f565b613732565b348015610ad057600080fd5b50610428600b5481565b348015610ae657600080fd5b5061040b610af53660046157fb565b613741565b348015610b0657600080fd5b506104b17f000000000000000000000000000000000000000000000000000000000000000081565b6000610b386129fb565b6040516370a0823160e01b815233600482015284907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906370a0823190602401602060405180830381865afa158015610b9e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bc29190615a90565b1015610c075760405162461bcd60e51b8152602060048201526014602482015273696e73756666696369656e742062616c616e636560601b6044820152606401610402565b6040516370a0823160e01b81523060048201526000907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906370a0823190602401602060405180830381865afa158015610c6e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c929190615a90565b90506000806000610ca16115aa565b9250925092506000610cbc610cb585613911565b8a906139be565b905080851015610ce1576000610cd28683615abf565b9050610cdf8484836139e0565b505b6040516370a0823160e01b8152306004820152600090610d76906001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906370a0823190602401602060405180830381865afa158015610d4c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d709190615a90565b83613c9b565b905088811015610dbc5760405162461bcd60e51b8152602060048201526011602482015270746f6f206d75636820736c69707061676560781b6044820152606401610402565b60405163b8ce670d60e01b81523360048201819052602482018c905260448201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169063b8ce670d906064016020604051808303816000875af1158015610e30573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e549190615a90565b50610e896001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000168983613cb1565b610e938186615abf565b60085542600755610eb46001600160a01b038916632098244360e21b613ce1565b15610f1a57604051632098244360e21b8152336004820152602481018290526001600160a01b03891690638260910c90604401600060405180830381600087803b158015610f0157600080fd5b505af1158015610f15573d6000803e3d6000fd5b505050505b60405181815233907f884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a94243649060200160405180910390a2955050505050505b9392505050565b606060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663c5c63e656040518163ffffffff1660e01b8152600401600060405180830381865afa158015610fc0573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610fe89190810190615ad2565b8051604080516000808252602082019092529293509091905b8281101561114957600084828151811061101d5761101d615b60565b60209081029190910101516040516355eb6b3560e01b81526001600160a01b0380831660048301529192506000917f000000000000000000000000000000000000000000000000000000000000000016906355eb6b3590602401602060405180830381865afa158015611094573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110b89190615b76565b604051622708db60e01b81526001600160a01b0384811660048301529190911690622708db90602401600060405180830381865afa1580156110fe573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526111269190810190615ad2565b90506111328482613cfd565b93505050808061114190615b93565b915050611001565b5061115381613e28565b935050505090565b6040516304042d6360e21b8152600481018290526000907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690631010b58c90602401602060405180830381865afa1580156111c3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111e79190615b76565b92915050565b6000610f578383335b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166348439e7e6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611256573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061127a9190615b76565b604051630325d16160e01b8152600481018690523360248201526001600160a01b039190911690630325d16190604401600060405180830381600087803b1580156112c457600080fd5b505af11580156112d8573d6000803e3d6000fd5b505050506112e7848484610b2e565b949350505050565b60607f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166322acb8676040518163ffffffff1660e01b8152600401600060405180830381865afa15801561134f573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526113779190810190615bac565b905090565b60006203f48060075461138f9190615c5f565b42111561139e5761137761315e565b5060085490565b6113ad613f1c565b670de0b6b3a76400008110156113fc5760405162461bcd60e51b8152602060048201526014602482015273666163746f722062656c6f77206d696e696d756d60601b6044820152606401610402565b68056bc75e2d6310000081111561144c5760405162461bcd60e51b8152602060048201526014602482015273666163746f722061626f7665206d6178696d756d60601b6044820152606401610402565b600a54810361146d5760405162461bcd60e51b815260040161040290615c72565b600a8190556040518181527f43b89d4b5fdc149d21160712a4e8a2c76927dccd7aae23fd717f753758044a6f906020015b60405180910390a150565b6114b1613f1c565b662386f26fc100008110156115025760405162461bcd60e51b81526020600482015260176024820152761a5b9d985b1a590819195c1959c81d1a1c995cda1bdb19604a1b6044820152606401610402565b67016345785d8a00008111156115545760405162461bcd60e51b81526020600482015260176024820152761a5b9d985b1a590819195c1959c81d1a1c995cda1bdb19604a1b6044820152606401610402565b60065481036115755760405162461bcd60e51b815260040161040290615c72565b60068190556040518181527f20da4a1840e5e1bb25784e941f370e4db630545ed9434c8c0bad8e421480595b9060200161149e565b600080606060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632630c12f6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561160f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116339190615b76565b604051638b2f0f4f60e01b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000811660048301529190911690638b2f0f4f90602401602060405180830381865afa15801561169b573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116bf9190615a90565b90506116cc816000613f76565b93509350935050909192565b6116e06129fb565b6117097f0000000000000000000000000000000000000000000000000000000000000000614279565b1561174f5760405162461bcd60e51b81526020600482015260166024820152751d5b99195c9b1e5a5b99c81a5cc819195c1959d9d95960521b6044820152606401610402565b6117588161446f565b61179b5760405162461bcd60e51b81526020600482015260146024820152731c1bdbdb081a5cc81b9bdd0819195c1959d9d95960621b6044820152606401610402565b604051630d9e5ebb60e21b81526001600160a01b0382811660048301527f000000000000000000000000000000000000000000000000000000000000000016906336797aec90602401600060405180830381600087803b1580156117fe57600080fd5b505af1158015611812573d6000803e3d6000fd5b505050506000806118216115aa565b925050915060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316637e412a7a84846040518363ffffffff1660e01b8152600401611876929190615c9b565b602060405180830381865afa158015611893573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118b79190615a90565b600c81905560095490915060ff1615611a1a576040516355eb6b3560e01b81526001600160a01b0385811660048301526000917f0000000000000000000000000000000000000000000000000000000000000000909116906355eb6b3590602401602060405180830381865afa158015611935573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906119599190615b76565b604051633dfa59d160e01b81523060048201526001600160a01b038781166024830152919250600091831690633dfa59d190604401602060405180830381865afa1580156119ab573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906119cf9190615a90565b905068056bc75e2d63100000811115611a175760098054600a54600b5561ff00196001600160401b03421662010000021669ffffffffffffffffff0019909116176101001790555b50505b6040516001600160a01b03851681527f7d90518f39c7f92fd9046bbb246d9c650dd159f73cca88aa7d919c89c040fa799060200160405180910390a150505050565b336001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614611aa45760405162461bcd60e51b815260040161040290615cb4565b600081611ab2576000611ab6565b6000195b9050611aec6001600160a01b0384167f0000000000000000000000000000000000000000000000000000000000000000836137ba565b505050565b611af9613f1c565b604051631dbe84a360e11b81526001600160a01b0382811660048301527f00000000000000000000000000000000000000000000000000000000000000001690633b7d094690602401600060405180830381600087803b158015611b5c57600080fd5b505af1158015611b70573d6000803e3d6000fd5b5050505060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632cdacb506040518163ffffffff1660e01b8152600401602060405180830381865afa158015611bd4573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611bf89190615b76565b6040516355eb6b3560e01b81526001600160a01b0384811660048301529192506000917f000000000000000000000000000000000000000000000000000000000000000016906355eb6b3590602401602060405180830381865afa158015611c64573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611c889190615b76565b604051631da958a960e21b81526001600160a01b03858116600483015291909116906376a562a490602401602060405180830381865afa158015611cd0573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611cf49190615b76565b9050611aec6001600160a01b0382168360006137ba565b6000611377611d1861315e565b613911565b60006112e733858585611d38565b6000610f57838333610b2e565b6000611d4660015442111590565b15611d7c5760405162461bcd60e51b81526020600482015260066024820152651c185d5cd95960d21b6044820152606401610402565b611d846129fb565b611dda604051806101400160405280600081526020016000815260200160008152602001600081526020016000815260200160008152602001606081526020016000815260200160008152602001606081525090565b60055460ff1615611e215760405162461bcd60e51b81526020600482015260116024820152703837b7b61034b99039b43aba103237bbb760791b6044820152606401610402565b60008511611e715760405162461bcd60e51b815260206004820152601d60248201527f6465706f73697420616d6f756e742063616e6e6f74206265207a65726f0000006044820152606401610402565b611e796145ce565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632630c12f6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611ed9573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611efd9190615b76565b604051638b2f0f4f60e01b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000811660048301529190911690638b2f0f4f90602401602060405180830381865afa158015611f65573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611f899190615a90565b9050611f96816001613f76565b60c085015260a084015260808301819052611fb090613911565b8252611fe76001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016333089614789565b60a082015160c08301516040516370a0823160e01b81523060048201526120849291906001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906370a0823190602401602060405180830381865afa15801561205b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061207f9190615a90565b6147c7565b61208f816002613f76565b61012085015261010084015260e0830181905260808301516120b091615abf565b602083018190526120c2908790613c9b565b6040830181905282516120d59190614a8f565b6060830181905285111561211f5760405162461bcd60e51b8152602060048201526011602482015270746f6f206d75636820736c69707061676560781b6044820152606401610402565b60e082015160085542600755831561230d576060820151604051630d4d151360e01b815230600482015260248101919091526001600160a01b0388811660448301527f00000000000000000000000000000000000000000000000000000000000000001690630d4d1513906064016020604051808303816000875af11580156121ac573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906121d09190615a90565b5060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166348439e7e6040518163ffffffff1660e01b8152600401602060405180830381865afa158015612231573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906122559190615b76565b90506122998184606001517f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316614aa89092919063ffffffff16565b60608301516040516333f1c33760e01b815260048101919091523060248201526001600160a01b0389811660448301528216906333f1c33790606401600060405180830381600087803b1580156122ef57600080fd5b505af1158015612303573d6000803e3d6000fd5b50505050506123b4565b6060820151604051630d4d151360e01b81526001600160a01b0389811660048301819052602483019390935260448201929092527f000000000000000000000000000000000000000000000000000000000000000090911690630d4d1513906064016020604051808303816000875af115801561238e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906123b29190615a90565b505b6123d3878360a001518460c00151856101000151866101200151614b37565b60608201516040805188815260208101929092526001600160a01b0389169133917fdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7910160405180910390a3506060015195945050505050565b612435613f1c565b61243f6000614d7f565b565b600080600061244e6115aa565b604051633f20953d60e11b815291945092506001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169150637e412a7a906124a29085908590600401615c9b565b602060405180830381865afa1580156124bf573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906124e39190615a90565b9250505090565b604051634eb3ffc360e01b81523360048201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690634eb3ffc390602401602060405180830381865afa15801561254e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906125729190615cdc565b6125b25760405162461bcd60e51b81526020600482015260116024820152703737ba103830bab9b29036b0b730b3b2b960791b6044820152606401610402565b6002546125bf9042615c5f565b60018190556040519081527f32fb7c9891bc4f963c7de9f1186d2a7755c7d6e9f4604dabe1d8bb3027c2f49e9060200160405180910390a1565b606060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663c5c63e656040518163ffffffff1660e01b8152600401600060405180830381865afa15801561265b573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526126839190810190615ad2565b9050600081516001600160401b038111156126a0576126a061592a565b6040519080825280602002602001820160405280156126e557816020015b60408051808201909152600080825260208201528152602001906001900390816126be5790505b50905060006126f26115aa565b9250505060005b825181101561278257604051806040016040528085838151811061271f5761271f615b60565b60200260200101516001600160a01b0316815260200183838151811061274757612747615b60565b602002602001015181525083828151811061276457612764615b60565b6020026020010181905250808061277a90615b93565b9150506126f9565b50909392505050565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316638c788de06040518163ffffffff1660e01b8152600401602060405180830381865afa1580156127eb573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113779190615a90565b336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146128575760405162461bcd60e51b815260040161040290615cb4565b61285f6129fb565b604051638dbfb25b60e01b81526001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690638dbfb25b906128ab908490600401615741565b600060405180830381600087803b1580156128c557600080fd5b505af11580156128d9573d6000803e3d6000fd5b5050505060008060006128ea6115aa565b92509250925060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316637e412a7a85846040518363ffffffff1660e01b8152600401612940929190615c9b565b602060405180830381865afa15801561295d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129819190615a90565b600c81905560095490915060ff1680156129a257506129a08284614dcf565b155b600980549115156101000261ff00199092169190911790556129c66012600a615ddd565b600b556009805469ffffffffffffffff0000191662010000426001600160401b0316021790556129f4614e64565b5050505050565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316639f82b2176040518163ffffffff1660e01b8152600401602060405180830381865afa158015612a5b573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612a7f9190615b76565b905060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663c5c63e656040518163ffffffff1660e01b8152600401600060405180830381865afa158015612ae1573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052612b099190810190615ad2565b905060005b8151811015611aec576000828281518110612b2b57612b2b615b60565b602002602001015190507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166355eb6b35826040518263ffffffff1660e01b8152600401612b9091906001600160a01b0391909116815260200190565b602060405180830381865afa158015612bad573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612bd19190615b76565b60405163e155c05760e01b81526001600160a01b038381166004830152919091169063e155c05790602401600060405180830381600087803b158015612c1657600080fd5b505af1158015612c2a573d6000803e3d6000fd5b50506040516339d16a2360e11b81526001600160a01b03848116600483015260009350871691506373a2d44690602401602060405180830381865afa158015612c77573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612c9b9190615b76565b90506001600160a01b03811615612d94576040516355eb6b3560e01b81526001600160a01b0382811660048301527f000000000000000000000000000000000000000000000000000000000000000016906355eb6b3590602401602060405180830381865afa158015612d12573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612d369190615b76565b60405163e155c05760e01b81526001600160a01b038381166004830152919091169063e155c05790602401600060405180830381600087803b158015612d7b57600080fd5b505af1158015612d8f573d6000803e3d6000fd5b505050505b50508080612da190615b93565b915050612b0e565b6000612db36129fb565b604051639765ca1560e01b81526001600160a01b0383811660048301526000917f000000000000000000000000000000000000000000000000000000000000000090911690639765ca15906024016020604051808303816000875af1158015612e20573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612e449190615a90565b604080516001600160a01b0386168152602081018390529192507fb6e3324444a482d3e4041851d767063381c41cd9abc8a3191a0b61e3896f9443910160405180910390a192915050565b60405163ac6c525160e01b81526001600160a01b0382811660048301526000917f00000000000000000000000000000000000000000000000000000000000000009091169063ac6c525190602401602060405180830381865afa158015612efa573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111e79190615a90565b612f26613f1c565b8060045403612f475760405162461bcd60e51b815260040161040290615c72565b6702c68af0bb140000811115612f9f5760405162461bcd60e51b815260206004820152601960248201527f726174696f206578636565647320757070657220626f756e64000000000000006044820152606401610402565b60048190556040518181527fcf75d305993755a06325155bdff6a203ff5eb28a3561e219588aeb6aba8b3b549060200161149e565b612fdc613f1c565b60095481151560ff9091161515036130065760405162461bcd60e51b815260040161040290615c72565b6009805460ff19168215159081179091556040519081527f279cee3d8f87ec526dc3da1f7f9000d2bedd53531863d9e85e52ea363c3d13059060200161149e565b60607f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663c5c63e656040518163ffffffff1660e01b8152600401600060405180830381865afa1580156130a7573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526113779190810190615ad2565b60405163c699e63360e01b81526001600160a01b0382811660048301526000917f00000000000000000000000000000000000000000000000000000000000000009091169063c699e63390602401602060405180830381865afa15801561313a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111e79190615cdc565b6000806127826115aa565b613171613f1c565b610e108110156131c35760405162461bcd60e51b815260206004820152601860248201527f7061757365206475726174696f6e20746f6f2073686f727400000000000000006044820152606401610402565b6203f4808111156132165760405162461bcd60e51b815260206004820152601760248201527f7061757365206475726174696f6e20746f6f206c6f6e670000000000000000006044820152606401610402565b60028190556040518181527fa959cb2cc91580147f93f66fb85db8f308cfdaef3989ab5265408ff80ef6fa669060200161149e565b60008060006132586115aa565b92509250506124e38183614dcf565b6000807f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632630c12f6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156132c8573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906132ec9190615b76565b604051638b2f0f4f60e01b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000811660048301529190911690638b2f0f4f90602401602060405180830381865afa158015613354573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906133789190615a90565b905061338f81613389611d1861137c565b906139be565b91505090565b336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146133dd5760405162461bcd60e51b815260040161040290615cb4565b60055460ff16156134295760405162461bcd60e51b81526020600482015260166024820152753837b7b61030b63932b0b23c9039b43aba103237bbb760511b6044820152606401610402565b6005805460ff191660011790556040517f4426aa1fb73e391071491fcfe21a88b5c38a0a0333a1f6e77161470439704cf890600090a1565b613469613f1c565b60405163d914cd4b60e01b81526001600160a01b0382811660048301527f0000000000000000000000000000000000000000000000000000000000000000169063d914cd4b90602401600060405180830381600087803b1580156134cc57600080fd5b505af11580156134e0573d6000803e3d6000fd5b5050505060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632cdacb506040518163ffffffff1660e01b8152600401602060405180830381865afa158015613544573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906135689190615b76565b6040516355eb6b3560e01b81526001600160a01b0384811660048301529192506000917f000000000000000000000000000000000000000000000000000000000000000016906355eb6b3590602401602060405180830381865afa1580156135d4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906135f89190615b76565b604051631da958a960e21b81526001600160a01b03858116600483015291909116906376a562a490602401602060405180830381865afa158015613640573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906136649190615b76565b9050611aec6001600160a01b038216836000196137ba565b613684613f1c565b80600354036136a55760405162461bcd60e51b815260040161040290615c72565b6702c68af0bb1400008111156136fd5760405162461bcd60e51b815260206004820152601d60248201527f646576696174696f6e206578636565647320757070657220626f756e640000006044820152606401610402565b60038190556040518181527f3f9ef5ed5d378ef819698e4b3c710d362f981f90087b428b7a1ee1e716d689d59060200161149e565b6000610f573384846001611d38565b613749613f1c565b6001600160a01b0381166137ae5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610402565b6137b781614d7f565b50565b8015806138345750604051636eb1769f60e11b81523060048201526001600160a01b03838116602483015284169063dd62ed3e90604401602060405180830381865afa15801561380e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906138329190615a90565b155b61389f5760405162461bcd60e51b815260206004820152603660248201527f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60448201527520746f206e6f6e2d7a65726f20616c6c6f77616e636560501b6064820152608401610402565b6040516001600160a01b038316602482015260448101829052611aec90849063095ea7b360e01b906064015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b03199093169290921790915261503b565b60606112e78484600085615110565b6000807f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166318160ddd6040518163ffffffff1660e01b8152600401602060405180830381865afa158015613972573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906139969190615a90565b90508015806139a3575082155b156139b457610f576012600a615ddd565b610f578382614a8f565b60006139cc6012600a615ddd565b6139d68385615de9565b610f579190615e00565b8060006139ed8286615abf565b905060006139fa856151eb565b90505b8215613c93576000807f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166339d825138585613a3f615289565b6040518463ffffffff1660e01b8152600401613a5d93929190615e22565b6040805180830381865afa158015613a79573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190613a9d9190615e4b565b6040516304042d6360e21b81526004810183905291935091506000906001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690631010b58c90602401602060405180830381865afa158015613b0a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190613b2e9190615b76565b90506000613b3c8784613c9b565b6040516355eb6b3560e01b81526001600160a01b0384811660048301529192506000917f000000000000000000000000000000000000000000000000000000000000000016906355eb6b3590602401602060405180830381865afa158015613ba8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190613bcc9190615b76565b6040516001600160a01b0380861660248301527f000000000000000000000000000000000000000000000000000000000000000016604482015260648101849052909150613c519060840160408051601f198184030181529190526020810180516001600160e01b0316636ce5768960e11b1790526001600160a01b038316906152a8565b50613c5c8289615abf565b975081868681518110613c7157613c71615b60565b60200260200101818151613c859190615abf565b9052506139fd945050505050565b505050505050565b6000818310613caa5781610f57565b5090919050565b6040516001600160a01b038316602482015260448101829052611aec90849063a9059cbb60e01b906064016138cb565b6000613cec836152cd565b8015610f575750610f578383615300565b606081518351613d0d9190615c5f565b6001600160401b03811115613d2457613d2461592a565b604051908082528060200260200182016040528015613d4d578160200160208202803683370190505b50905060005b8351811015613db257838181518110613d6e57613d6e615b60565b6020026020010151828281518110613d8857613d88615b60565b6001600160a01b039092166020928302919091019091015280613daa81615b93565b915050613d53565b5060005b8251811015613e2157828181518110613dd157613dd1615b60565b602002602001015182855183613de79190615c5f565b81518110613df757613df7615b60565b6001600160a01b039092166020928302919091019091015280613e1981615b93565b915050613db6565b5092915050565b6060600082516001600160401b03811115613e4557613e4561592a565b604051908082528060200260200182016040528015613e6e578160200160208202803683370190505b5090506000805b8451811015613f1157613ea283868381518110613e9457613e94615b60565b602002602001015184615385565b613eff57848181518110613eb857613eb8615b60565b6020026020010151838380613ecc90615b93565b945081518110613ede57613ede615b60565b60200260200101906001600160a01b031690816001600160a01b0316815250505b80613f0981615b93565b915050613e75565b506112e782826153ea565b6000546001600160a01b0316331461243f5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610402565b600080606060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663c5c63e656040518163ffffffff1660e01b8152600401600060405180830381865afa158015613fdb573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526140039190810190615ad2565b8051909150806001600160401b038111156140205761402061592a565b604051908082528060200260200182016040528015614049578160200160208202803683370190505b50925060005b818110156141db57600083828151811061406b5761406b615b60565b60209081029190910101516040516355eb6b3560e01b81526001600160a01b0380831660048301529192506000917f000000000000000000000000000000000000000000000000000000000000000016906355eb6b3590602401602060405180830381865afa1580156140e2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906141069190615b76565b6001600160a01b0316630fee68b330847f00000000000000000000000000000000000000000000000000000000000000008e8e6040518663ffffffff1660e01b8152600401614159959493929190615e6f565b602060405180830381865afa158015614176573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061419a9190615a90565b9050808684815181106141af576141af615b60565b60209081029190910101526141c48188615c5f565b9650505080806141d390615b93565b91505061404f565b506040516370a0823160e01b81523060048201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906370a0823190602401602060405180830381865afa158015614240573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906142649190615a90565b61426e9085615c5f565b945050509250925092565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316826001600160a01b0316036142bc57506000919050565b6001600160a01b038083166000908152600d60209081526040808320548151632630c12f60e01b8152915190947f00000000000000000000000000000000000000000000000000000000000000001692632630c12f92600480820193918290030181865afa158015614332573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906143569190615b76565b604051638b2f0f4f60e01b81526000600482018190529192506001600160a01b03831690638b2f0f4f90602401602060405180830381865afa1580156143a0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906143c49190615a90565b604051638b2f0f4f60e01b81526001600160a01b038781166004830152919250600091841690638b2f0f4f90602401602060405180830381865afa158015614410573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906144349190615a90565b905060006144428284614a8f565b905060006144508683615491565b9050600061445e8288614a8f565b600654109998505050505050505050565b6040516355eb6b3560e01b81526001600160a01b03828116600483015260009182917f000000000000000000000000000000000000000000000000000000000000000016906355eb6b3590602401602060405180830381865afa1580156144da573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906144fe9190615b76565b604051622708db60e01b81526001600160a01b0385811660048301529190911690622708db90602401600060405180830381865afa158015614544573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f1916820160405261456c9190810190615ad2565b905060005b81518110156145c457600082828151811061458e5761458e615b60565b602002602001015190506145a181614279565b156145b157506001949350505050565b50806145bc81615b93565b915050614571565b5060009392505050565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663c5c63e656040518163ffffffff1660e01b8152600401600060405180830381865afa15801561462e573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526146569190810190615ad2565b805190915060005b81811015611aec57600083828151811061467a5761467a615b60565b60209081029190910101516040516355eb6b3560e01b81526001600160a01b0380831660048301529192506000917f000000000000000000000000000000000000000000000000000000000000000016906355eb6b3590602401602060405180830381865afa1580156146f1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906147159190615b76565b60405163415ec73b60e01b81526001600160a01b0384811660048301529192509082169063415ec73b90602401600060405180830381600087803b15801561475c57600080fd5b505af1158015614770573d6000803e3d6000fd5b505050505050808061478190615b93565b91505061465e565b6040516001600160a01b03808516602483015283166044820152606481018290526147c19085906323b872dd60e01b906084016138cb565b50505050565b8060006147d48286615c5f565b905060006147e1856151eb565b90505b8215613c93576000807f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166312968a298585614826615289565b6040518463ffffffff1660e01b815260040161484493929190615e22565b6040805180830381865afa158015614860573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906148849190615e4b565b9092509050614894816064615c5f565b85101561489e5750835b6040516304042d6360e21b8152600481018390526000907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690631010b58c90602401602060405180830381865afa158015614906573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061492a9190615b76565b905060006149388784613c9b565b6040516355eb6b3560e01b81526001600160a01b0384811660048301529192506000917f000000000000000000000000000000000000000000000000000000000000000016906355eb6b3590602401602060405180830381865afa1580156149a4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906149c89190615b76565b6040516001600160a01b0380861660248301527f000000000000000000000000000000000000000000000000000000000000000016604482015260648101849052909150614a4d9060840160408051601f198184030181529190526020810180516001600160e01b0316638340f54960e01b1790526001600160a01b038316906152a8565b50614a588289615abf565b975081868681518110614a6d57614a6d615b60565b60200260200101818151614a819190615c5f565b9052506147e4945050505050565b600081614a9e6012600a615ddd565b6139d69085615de9565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663095ea7b360e01b179052614af984826154a9565b6147c1576040516001600160a01b038416602482015260006044820152614b2d90859063095ea7b360e01b906064016138cb565b6147c1848261503b565b600954610100900460ff16156129f457604051633f20953d60e11b81526000906001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690637e412a7a90614b989088908890600401615c9b565b602060405180830381865afa158015614bb5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190614bd99190615a90565b905060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316637e412a7a85856040518363ffffffff1660e01b8152600401614c2b929190615c9b565b602060405180830381865afa158015614c48573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190614c6c9190615a90565b90507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663dbcd89fa6040518163ffffffff1660e01b8152600401602060405180830381865afa158015614ccc573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190614cf09190615b76565b604051630a48af5f60e11b81526001600160a01b038981166004830152602482018590526044820184905291909116906314915ebe90606401600060405180830381600087803b158015614d4357600080fd5b505af1158015614d57573d6000803e3d6000fd5b50505050614d658385614dcf565b15614d76576009805461ff00191690555b50505050505050565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6003546040516328cb81ef60e11b81526000916001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169163519703de91614e239187918791600401615ec4565b602060405180830381865afa158015614e40573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f579190615cdc565b6000614e6e610f5e565b905060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632630c12f6040518163ffffffff1660e01b8152600401602060405180830381865afa158015614ed0573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190614ef49190615b76565b604051638b2f0f4f60e01b81526000600482018190529192506001600160a01b03831690638b2f0f4f90602401602060405180830381865afa158015614f3e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190614f629190615a90565b905060005b83518110156147c1576000848281518110614f8457614f84615b60565b6020908102919091010151604051638b2f0f4f60e01b81526001600160a01b038083166004830152919250600091861690638b2f0f4f90602401602060405180830381865afa158015614fdb573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190614fff9190615a90565b905061500b8185614a8f565b6001600160a01b039092166000908152600d6020526040902091909155508061503381615b93565b915050614f67565b6000615090826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166139029092919063ffffffff16565b90508051600014806150b15750808060200190518101906150b19190615cdc565b611aec5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b6064820152608401610402565b6060824710156151715760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b6064820152608401610402565b600080866001600160a01b0316858760405161518d9190615f0d565b60006040518083038185875af1925050503d80600081146151ca576040519150601f19603f3d011682016040523d82523d6000602084013e6151cf565b606091505b50915091506151e087838387615550565b979650505050505050565b6060600082516001600160401b038111156152085761520861592a565b604051908082528060200260200182016040528015615231578160200160208202803683370190505b50905060005b8351811015613e215783818151811061525257615252615b60565b602002602001015182828151811061526c5761526c615b60565b60209081029190910101528061528181615b93565b915050615237565b600954600090610100900460ff166152a2575060035490565b50600090565b6060610f578383604051806060016040528060278152602001615f5d602791396155c9565b60006152e0826301ffc9a760e01b615300565b80156111e757506152f9826001600160e01b0319615300565b1592915050565b604080516001600160e01b03198316602480830191909152825180830390910181526044909101909152602080820180516001600160e01b03166301ffc9a760e01b178152825160009392849283928392918391908a617530fa92503d91506000519050828015615372575060208210155b80156151e0575015159695505050505050565b6000805b828110156153df57836001600160a01b03168582815181106153ad576153ad615b60565b60200260200101516001600160a01b0316036153cd576001915050610f57565b806153d781615b93565b915050615389565b506000949350505050565b6060816001600160401b038111156154045761540461592a565b60405190808252806020026020018201604052801561542d578160200160208202803683370190505b50905060005b82811015613e215783818151811061544d5761544d615b60565b602002602001015182828151811061546757615467615b60565b6001600160a01b03909216602092830291909101909101528061548981615b93565b915050615433565b6000818310156154a357828203610f57565b50900390565b6000806000846001600160a01b0316846040516154c69190615f0d565b6000604051808303816000865af19150503d8060008114615503576040519150601f19603f3d011682016040523d82523d6000602084013e615508565b606091505b50915091508180156155325750805115806155325750808060200190518101906155329190615cdc565b801561554757506001600160a01b0385163b15155b95945050505050565b606083156155bf5782516000036155b8576001600160a01b0385163b6155b85760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610402565b50816112e7565b6112e78383615641565b6060600080856001600160a01b0316856040516155e69190615f0d565b600060405180830381855af49150503d8060008114615621576040519150601f19603f3d011682016040523d82523d6000602084013e615626565b606091505b509150915061563786838387615550565b9695505050505050565b8151156156515781518083602001fd5b8060405162461bcd60e51b81526004016104029190615f29565b6001600160a01b03811681146137b757600080fd5b60008060006060848603121561569557600080fd5b833592506020840135915060408401356156ae8161566b565b809150509250925092565b6020808252825182820181905260009190848201906040850190845b818110156156fa5783516001600160a01b0316835292840192918401916001016156d5565b50909695505050505050565b60006020828403121561571857600080fd5b5035919050565b6000806040838503121561573257600080fd5b50508035926020909101359150565b602080825282518282018190526000919060409081850190868401855b828110156157945761578484835180516001600160a01b03168252602090810151910152565b928401929085019060010161575e565b5091979650505050505050565b600081518084526020808501945080840160005b838110156157d1578151875295820195908201906001016157b5565b509495945050505050565b83815282602082015260606040820152600061554760608301846157a1565b60006020828403121561580d57600080fd5b8135610f578161566b565b80151581146137b757600080fd5b6000806040838503121561583957600080fd5b82356158448161566b565b9150602083013561585481615818565b809150509250929050565b60008060006060848603121561587457600080fd5b833592506020840135915060408401356156ae81615818565b600080600080608085870312156158a357600080fd5b84356158ae8161566b565b9350602085013592506040850135915060608501356158cc81615818565b939692955090935050565b602080825282518282018190526000919060409081850190868401855b828110156157945761591a84835180516001600160a01b03168252602090810151910152565b92840192908501906001016158f4565b634e487b7160e01b600052604160045260246000fd5b604080519081016001600160401b03811182821017156159625761596261592a565b60405290565b604051601f8201601f191681016001600160401b03811182821017156159905761599061592a565b604052919050565b60006001600160401b038211156159b1576159b161592a565b5060051b60200190565b600060208083850312156159ce57600080fd5b82356001600160401b038111156159e457600080fd5b8301601f810185136159f557600080fd5b8035615a08615a0382615998565b615968565b81815260069190911b82018301908381019087831115615a2757600080fd5b928401925b828410156151e05760408489031215615a455760008081fd5b615a4d615940565b8435615a588161566b565b81528486013586820152825260409093019290840190615a2c565b600060208284031215615a8557600080fd5b8135610f5781615818565b600060208284031215615aa257600080fd5b5051919050565b634e487b7160e01b600052601160045260246000fd5b818103818111156111e7576111e7615aa9565b60006020808385031215615ae557600080fd5b82516001600160401b03811115615afb57600080fd5b8301601f81018513615b0c57600080fd5b8051615b1a615a0382615998565b81815260059190911b82018301908381019087831115615b3957600080fd5b928401925b828410156151e0578351615b518161566b565b82529284019290840190615b3e565b634e487b7160e01b600052603260045260246000fd5b600060208284031215615b8857600080fd5b8151610f578161566b565b600060018201615ba557615ba5615aa9565b5060010190565b60006020808385031215615bbf57600080fd5b82516001600160401b03811115615bd557600080fd5b8301601f81018513615be657600080fd5b8051615bf4615a0382615998565b81815260069190911b82018301908381019087831115615c1357600080fd5b928401925b828410156151e05760408489031215615c315760008081fd5b615c39615940565b8451615c448161566b565b81528486015186820152825260409093019290840190615c18565b808201808211156111e7576111e7615aa9565b6020808252600f908201526e1cd85b5948185cc818dd5c9c995b9d608a1b604082015260600190565b8281526040602082015260006112e760408301846157a1565b6020808252600e908201526d1b9bdd08185d5d1a1bdc9a5e995960921b604082015260600190565b600060208284031215615cee57600080fd5b8151610f5781615818565b600181815b80851115615d34578160001904821115615d1a57615d1a615aa9565b80851615615d2757918102915b93841c9390800290615cfe565b509250929050565b600082615d4b575060016111e7565b81615d58575060006111e7565b8160018114615d6e5760028114615d7857615d94565b60019150506111e7565b60ff841115615d8957615d89615aa9565b50506001821b6111e7565b5060208310610133831016604e8410600b8410161715615db7575081810a6111e7565b615dc18383615cf9565b8060001904821115615dd557615dd5615aa9565b029392505050565b6000610f578383615d3c565b80820281158282048414176111e7576111e7615aa9565b600082615e1d57634e487b7160e01b600052601260045260246000fd5b500490565b838152606060208201526000615e3b60608301856157a1565b9050826040830152949350505050565b60008060408385031215615e5e57600080fd5b505080516020909101519092909150565b6001600160a01b0386811682528581166020830152841660408201526060810183905260a0810160038310615eb457634e487b7160e01b600052602160045260246000fd5b8260808301529695505050505050565b606081526000615ed760608301866157a1565b60208301949094525060400152919050565b60005b83811015615f04578181015183820152602001615eec565b50506000910152565b60008251615f1f818460208701615ee9565b9190910192915050565b6020815260008251806020840152615f48816040850160208701615ee9565b601f01601f1916919091016040019291505056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a264697066735822122060b0e9196d6241f316cb329e4441f60135a7f7bb8ff4dfc732d4ce3682a2e95764736f6c6343000811003360c06040523480156200001157600080fd5b506040516200151738038062001517833981016040819052620000349162000166565b818160036200004483826200029f565b5060046200005382826200029f565b505050506001600160a01b0393841660805250911660a0526006805460ff191660ff9092169190911790556200036b565b80516001600160a01b03811681146200009c57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b600082601f830112620000c957600080fd5b81516001600160401b0380821115620000e657620000e6620000a1565b604051601f8301601f19908116603f01168101908282118183101715620001115762000111620000a1565b816040528381526020925086838588010111156200012e57600080fd5b600091505b8382101562000152578582018301518183018401529082019062000133565b600093810190920192909252949350505050565b600080600080600060a086880312156200017f57600080fd5b6200018a8662000084565b94506200019a6020870162000084565b9350604086015160ff81168114620001b157600080fd5b60608701519093506001600160401b0380821115620001cf57600080fd5b620001dd89838a01620000b7565b93506080880151915080821115620001f457600080fd5b506200020388828901620000b7565b9150509295509295909350565b600181811c908216806200022557607f821691505b6020821081036200024657634e487b7160e01b600052602260045260246000fd5b50919050565b601f8211156200029a57600081815260208120601f850160051c81016020861015620002755750805b601f850160051c820191505b81811015620002965782815560010162000281565b5050505b505050565b81516001600160401b03811115620002bb57620002bb620000a1565b620002d381620002cc845462000210565b846200024c565b602080601f8311600181146200030b5760008415620002f25750858301515b600019600386901b1c1916600185901b17855562000296565b600085815260208120601f198616915b828110156200033c578886015182559484019460019091019084016200031b565b50858210156200035b5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b60805160a051611155620003c2600039600081816101280152818161035b01526104a8015260008181610280015281816104fb01528181610729015281816107b101528181610d450152610e0901526111556000f3fe608060405234801561001057600080fd5b50600436106101005760003560e01c806370a0823111610097578063b8ce670d11610066578063b8ce670d14610240578063c5c94cee14610253578063dd62ed3e14610268578063f77c47911461027b57600080fd5b806370a08231146101e957806395d89b4114610212578063a457c2d71461021a578063a9059cbb1461022d57600080fd5b806318160ddd116100d357806318160ddd146101a657806323b872dd146101ae578063313ce567146101c157806339509351146101d657600080fd5b806306fdde03146101055780630754617214610123578063095ea7b3146101625780630d4d151314610185575b600080fd5b61010d6102a2565b60405161011a9190610ed2565b60405180910390f35b61014a7f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b03909116815260200161011a565b610175610170366004610f38565b610334565b604051901515815260200161011a565b610198610193366004610f64565b61034e565b60405190815260200161011a565b600254610198565b6101756101bc366004610fa6565b6103bd565b60065460405160ff909116815260200161011a565b6101756101e4366004610f38565b6103e1565b6101986101f7366004610fe7565b6001600160a01b031660009081526020819052604090205490565b61010d610403565b610175610228366004610f38565b610412565b61017561023b366004610f38565b61048d565b61019861024e366004610f64565b61049b565b610266610261366004610fa6565b6104f9565b005b61019861027636600461100b565b6105bb565b61014a7f000000000000000000000000000000000000000000000000000000000000000081565b6060600380546102b190611044565b80601f01602080910402602001604051908101604052809291908181526020018280546102dd90611044565b801561032a5780601f106102ff5761010080835404028352916020019161032a565b820191906000526020600020905b81548152906001019060200180831161030d57829003601f168201915b5050505050905090565b6000336103428185856105e6565b60019150505b92915050565b6000336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146103a15760405162461bcd60e51b81526004016103989061107e565b60405180910390fd5b6103ab828461070a565b6103b584846108be565b509092915050565b6000336103cb858285610989565b6103d6858585610a03565b506001949350505050565b6000336103428185856103f483836105bb565b6103fe91906110a6565b6105e6565b6060600480546102b190611044565b6000338161042082866105bb565b9050838110156104805760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604482015264207a65726f60d81b6064820152608401610398565b6103d682868684036105e6565b600033610342818585610a03565b6000336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146104e55760405162461bcd60e51b81526004016103989061107e565b6104ef828461070a565b6103b58484610bb2565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166348439e7e6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610557573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061057b91906110c7565b6001600160a01b0316336001600160a01b0316146105ab5760405162461bcd60e51b81526004016103989061107e565b6105b6838383610cf0565b505050565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b6001600160a01b0383166106485760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401610398565b6001600160a01b0382166106a95760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401610398565b6001600160a01b0383811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b604051636b6ba9bf60e11b81526001600160a01b0383811660048301527f0000000000000000000000000000000000000000000000000000000000000000169063d6d7537e90602401602060405180830381865afa158015610770573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061079491906110e4565b158015610827575060405163038d8da360e51b81523060048201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906371b1b46090602401602060405180830381865afa158015610800573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108249190611106565b81115b156108ba576001600160a01b03821660009081526005602052604090205443900361089e5760405162461bcd60e51b815260206004820152602160248201527f63616e6e6f74206d696e742f6275726e20747769636520696e206120626c6f636044820152606b60f81b6064820152608401610398565b6001600160a01b03821660009081526005602052604090204390555b5050565b6001600160a01b0382166109145760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f2061646472657373006044820152606401610398565b61092060008383610dde565b806002600082825461093291906110a6565b90915550506001600160a01b038216600081815260208181526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a35050565b600061099584846105bb565b905060001981146109fd57818110156109f05760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000006044820152606401610398565b6109fd84848484036105e6565b50505050565b6001600160a01b038316610a675760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b6064820152608401610398565b6001600160a01b038216610ac95760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b6064820152608401610398565b610ad4838383610dde565b6001600160a01b03831660009081526020819052604090205481811015610b4c5760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b6064820152608401610398565b6001600160a01b03848116600081815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a36109fd565b6001600160a01b038216610c125760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f206164647265736044820152607360f81b6064820152608401610398565b610c1e82600083610dde565b6001600160a01b03821660009081526020819052604090205481811015610c925760405162461bcd60e51b815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e604482015261636560f01b6064820152608401610398565b6001600160a01b0383166000818152602081815260408083208686039055600280548790039055518581529192917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3505050565b816001600160a01b0316836001600160a01b031614158015610d2957506001600160a01b03831660009081526005602052604090205443145b8015610dbb575060405163038d8da360e51b81523060048201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906371b1b46090602401602060405180830381865afa158015610d94573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610db89190611106565b81115b156105b657506001600160a01b0316600090815260056020526040902043905550565b6001600160a01b0383161580610dfb57506001600160a01b038216155b15610e0557505050565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166348439e7e6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610e65573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e8991906110c7565b9050806001600160a01b0316846001600160a01b03161480610ebc5750806001600160a01b0316836001600160a01b0316145b15610ec75750505050565b6109fd848484610cf0565b600060208083528351808285015260005b81811015610eff57858101830151858201604001528201610ee3565b506000604082860101526040601f19601f8301168501019250505092915050565b6001600160a01b0381168114610f3557600080fd5b50565b60008060408385031215610f4b57600080fd5b8235610f5681610f20565b946020939093013593505050565b600080600060608486031215610f7957600080fd5b8335610f8481610f20565b9250602084013591506040840135610f9b81610f20565b809150509250925092565b600080600060608486031215610fbb57600080fd5b8335610fc681610f20565b92506020840135610fd681610f20565b929592945050506040919091013590565b600060208284031215610ff957600080fd5b813561100481610f20565b9392505050565b6000806040838503121561101e57600080fd5b823561102981610f20565b9150602083013561103981610f20565b809150509250929050565b600181811c9082168061105857607f821691505b60208210810361107857634e487b7160e01b600052602260045260246000fd5b50919050565b6020808252600e908201526d1b9bdd08185d5d1a1bdc9a5e995960921b604082015260600190565b8082018082111561034857634e487b7160e01b600052601160045260246000fd5b6000602082840312156110d957600080fd5b815161100481610f20565b6000602082840312156110f657600080fd5b8151801515811461100457600080fd5b60006020828403121561111857600080fd5b505191905056fea2646970667358221220160f75bd8dd6eee3c41e6e92401893b9d88332b6b4536dec6eb583525622a08364736f6c6343000811003360e06040523480156200001157600080fd5b506040516200288a3803806200288a833981016040819052620000349162000069565b336080526001600160a01b0391821660a0521660c052620000a8565b6001600160a01b03811681146200006657600080fd5b50565b600080604083850312156200007d57600080fd5b82516200008a8162000050565b60208401519092506200009d8162000050565b809150509250929050565b60805160a05160c05161273b6200014f600039600081816101eb0152818161074a015281816107c501528181610df101528181610e6c01526116ab0152600081816102d6015281816106b301528181610a6e01528181610d5a015281816113450152818161161f01526117d80152600081816102120152818161056f0152818161096e01528181610af201528181611043015281816112af0152611526015261273b6000f3fe608060405234801561001057600080fd5b50600436106101165760003560e01c80637e412a7a116100a2578063ac6c525111610071578063ac6c525114610283578063c5c63e6514610296578063c699e633146102ab578063d914cd4b146102be578063f77c4791146102d157600080fd5b80637e412a7a146102345780638c788de0146102555780638dbfb25b1461025d5780639765ca151461027057600080fd5b806339d82513116100e957806339d825131461019d5780633b7d0946146101b0578063519703de146101c35780636f307dc3146101e65780637d59ce011461020d57600080fd5b80631010b58c1461011b57806312968a291461014b57806322acb8671461017357806336797aec14610188575b600080fd5b61012e610129366004612116565b6102f8565b6040516001600160a01b0390911681526020015b60405180910390f35b61015e61015936600461222e565b61030a565b60408051928352602083019190915201610142565b61017b61047d565b604051610142919061227e565b61019b6101963660046122eb565b610564565b005b61015e6101ab36600461222e565b610658565b61019b6101be3660046122eb565b610963565b6101d66101d1366004612308565b610cf9565b6040519015158152602001610142565b61012e7f000000000000000000000000000000000000000000000000000000000000000081565b61012e7f000000000000000000000000000000000000000000000000000000000000000081565b610247610242366004612356565b610fa4565b604051908152602001610142565b610247611027565b61019b61026b36600461239d565b611038565b61024761027e3660046122eb565b6112a2565b6102476102913660046122eb565b6114f6565b61029e611503565b604051610142919061245c565b6101d66102b93660046122eb565b61150f565b61019b6102cc3660046122eb565b61151b565b61012e7f000000000000000000000000000000000000000000000000000000000000000081565b600061030481836119ab565b92915050565b81516000908190600019825b8281101561041a57600061032a81836119ab565b90506000888381518110610340576103406124a9565b6020026020010151905060006103608360026119b790919063ffffffff16565b9050600061036e8c836119cc565b90508083106103805750505050610408565b60006103a38b6103926012600a6125b9565b61039c91906125c5565b84906119cc565b90506103b16012600a6125b9565b81116103bd57806103c9565b6103c96012600a6125b9565b905060006103d78e836119cc565b905060006103e586836125d8565b90508a81116103fa5750505050505050610408565b809a50879850505050505050505b80610412816125eb565b915050610316565b5060001981136104715760405162461bcd60e51b815260206004820152601d60248201527f6572726f722072657472696576696e67206465706f73697420706f6f6c00000060448201526064015b60405180910390fd5b96919550909350505050565b6060600061048b60006119ee565b905060008167ffffffffffffffff8111156104a8576104a861212f565b6040519080825280602002602001820160405280156104ed57816020015b60408051808201909152600080825260208201528152602001906001900390816104c65790505b50905060005b8281101561055d576000806105096002846119f8565b915091506040518060400160405280836001600160a01b031681526020018281525084848151811061053d5761053d6124a9565b602002602001018190525050508080610555906125eb565b9150506104f3565b5092915050565b336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146105ac5760405162461bcd60e51b815260040161046890612604565b6105b58161150f565b6105fa5760405162461bcd60e51b81526020600482015260166024820152751c1bdbdb081a5cc81b9bdd081c9959da5cdd195c995960521b6044820152606401610468565b6106056002826119b7565b60000361064c5760405162461bcd60e51b81526020600482015260156024820152740706f6f6c2077656967687420616c7265616479203605c1b6044820152606401610468565b61065581611a14565b50565b81516000908190600019825b8281101561090957600061067881836119ab565b905060006106876002836119b7565b9050600089848151811061069d5761069d6124a9565b60200260200101519050816000036108945760007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632630c12f6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561070f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610733919061262c565b604051638b2f0f4f60e01b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000811660048301529190911690638b2f0f4f90602401602060405180830381865afa15801561079b573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107bf9190612649565b905060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663313ce5676040518163ffffffff1660e01b8152600401602060405180830381865afa158015610821573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108459190612662565b61085090600a612685565b61085a8484612694565b61086491906126ab565b905061087a600268056bc75e2d631000006126ab565b81106108915750939750955061095b945050505050565b50505b60006108a08c846119cc565b90508082116108b257505050506108f7565b60006108be828c6119cc565b6108c890836125d8565b905060006108d682856125d8565b90508981116108ea575050505050506108f7565b8099508697505050505050505b80610901816125eb565b915050610664565b5060001981136104715760405162461bcd60e51b815260206004820152601e60248201527f6572726f722072657472696576696e6720776974686472617720706f6f6c00006044820152606401610468565b935093915050565b336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146109ab5760405162461bcd60e51b815260040161046890612604565b6109b6600082611d6b565b6109f35760405162461bcd60e51b815260206004820152600e60248201526d1c1bdbdb081b9bdd08185919195960921b6044820152606401610468565b60016109ff60006119ee565b11610a4c5760405162461bcd60e51b815260206004820152601760248201527f63616e6e6f742072656d6f7665206c61737420706f6f6c0000000000000000006044820152606401610468565b6040516355eb6b3560e01b81526001600160a01b0382811660048301526000917f0000000000000000000000000000000000000000000000000000000000000000909116906355eb6b3590602401602060405180830381865afa158015610ab7573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610adb919061262c565b604051633dfa59d160e01b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000811660048301528481166024830152919250600091831690633dfa59d190604401602060405180830381865afa158015610b4f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b739190612649565b905068056bc75e2d631000008110610bcd5760405162461bcd60e51b815260206004820152601860248201527f706f6f6c2068617320616c6c6f63617465642066756e647300000000000000006044820152606401610468565b6000610bda6002856119b7565b90508015610c205760405162461bcd60e51b81526020600482015260136024820152721c1bdbdb081a185cc81dd95a59da1d081cd95d606a1b6044820152606401610468565b610c2b600085611d8d565b610c6a5760405162461bcd60e51b815260206004820152601060248201526f1c1bdbdb081b9bdd081c995b5bdd995960821b6044820152606401610468565b610c75600285611da2565b610cb65760405162461bcd60e51b81526020600482015260126024820152711dd95a59da1d081b9bdd081c995b5bdd995960721b6044820152606401610468565b6040516001600160a01b03851681527fca2456580e344539a90d4d0369fc77866a3135141e2e51621b88d2f010c6bbe2906020015b60405180910390a150505050565b600082600003610d0b57506001610f9d565b60005b8451811015610f97576000610d2e610d2682846119ab565b6002906119b7565b90506000868381518110610d4457610d446124a9565b6020026020010151905081600003610f3e5760007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632630c12f6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610db6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610dda919061262c565b604051638b2f0f4f60e01b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000811660048301529190911690638b2f0f4f90602401602060405180830381865afa158015610e42573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e669190612649565b905060007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663313ce5676040518163ffffffff1660e01b8152600401602060405180830381865afa158015610ec8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610eec9190612662565b610ef790600a612685565b610f018484612694565b610f0b91906126ab565b9050610f21600268056bc75e2d631000006126ab565b8110610f3557600095505050505050610f9d565b50505050610f85565b6000610f4a87846119cc565b90506000610f588284611db7565b90506000610f668284611dcf565b905087811115610f7f5760009650505050505050610f9d565b50505050505b80610f8f816125eb565b915050610d0e565b50600190505b9392505050565b60008060005b835181101561101f576000610fc2610d2682846119ab565b90506000610fd087836119cc565b9050610ffe868481518110610fe757610fe76124a9565b602002602001015182611db790919063ffffffff16565b61100890856125c5565b935050508080611017906125eb565b915050610faa565b509392505050565b600061103360006119ee565b905090565b336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146110805760405162461bcd60e51b815260040161046890612604565b61108a60006119ee565b8151146110d05760405162461bcd60e51b8152602060048201526014602482015273696e76616c696420706f6f6c207765696768747360601b6044820152606401610468565b60008060005b83518110156112425760008482815181106110f3576110f36124a9565b6020026020010151600001519050826001600160a01b0316816001600160a01b0316116111555760405162461bcd60e51b815260206004820152601060248201526f1c1bdbdb1cc81b9bdd081cdbdc9d195960821b6044820152606401610468565b61115e8161150f565b6111a35760405162461bcd60e51b81526020600482015260166024820152751c1bdbdb081a5cc81b9bdd081c9959da5cdd195c995960521b6044820152606401610468565b60008583815181106111b7576111b76124a9565b60200260200101516020015190506111db82826002611de89092919063ffffffff16565b50816001600160a01b03167f49175c3467edeba7662e939bf84305eaf5084072855b0560f6ac3e145cd172ae8260405161121791815260200190565b60405180910390a261122981866125c5565b945090925081905061123a816125eb565b9150506110d6565b5061124f6012600a6125b9565b821461129d5760405162461bcd60e51b815260206004820152601760248201527f7765696768747320646f206e6f742073756d20746f20310000000000000000006044820152606401610468565b505050565b6000336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146112ec5760405162461bcd60e51b815260040161046890612604565b6112f58261150f565b6113415760405162461bcd60e51b815260206004820152601960248201527f637572766520706f6f6c206e6f742072656769737465726564000000000000006044820152606401610468565b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316639f82b2176040518163ffffffff1660e01b8152600401602060405180830381865afa1580156113a1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113c5919061262c565b6040516343b55f3560e01b81526001600160a01b0385811660048301529192506000918316906343b55f3590602401602060405180830381865afa158015611411573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906114359190612649565b604051631cec69e560e11b8152600481018290529091506001600160a01b038316906339d8d3ca90602401602060405180830381865afa15801561147d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906114a191906126cd565b6114ed5760405162461bcd60e51b815260206004820181905260248201527f636f6e76657820706f6f6c20706964206973206e6f74207368757420646f776e6044820152606401610468565b610f9d84611a14565b60006103046002836119b7565b60606110336000611e06565b60006103048183611d6b565b336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146115635760405162461bcd60e51b815260040161046890612604565b600a61156f60006119ee565b106115b05760405162461bcd60e51b81526020600482015260116024820152701b585e081c1bdbdb1cc81c995858da1959607a1b6044820152606401610468565b6115bb600082611d6b565b156115fd5760405162461bcd60e51b81526020600482015260126024820152711c1bdbdb08185b1c9958591e48185919195960721b6044820152606401610468565b6040516355eb6b3560e01b81526001600160a01b0382811660048301526000917f0000000000000000000000000000000000000000000000000000000000000000909116906355eb6b3590602401602060405180830381865afa158015611668573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061168c919061262c565b604051632aa2d3f760e21b81526001600160a01b0384811660048301527f00000000000000000000000000000000000000000000000000000000000000008116602483015291925060009183169063aa8b4fdc90604401602060405180830381865afa158015611700573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061172491906126cd565b9050806117665760405162461bcd60e51b815260206004820152601060248201526f18dbda5b881b9bdd081a5b881c1bdbdb60821b6044820152606401610468565b604051631da958a960e21b81526001600160a01b038481166004830152600091908416906376a562a490602401602060405180830381865afa1580156117b0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117d4919061262c565b90507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632630c12f6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611834573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611858919061262c565b6040516375151b6360e01b81526001600160a01b03838116600483015291909116906375151b6390602401602060405180830381865afa1580156118a0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118c491906126cd565b6119085760405162461bcd60e51b815260206004820152601560248201527431b0b73737ba10383934b1b2902628102a37b5b2b760591b6044820152606401610468565b611913600285611e13565b611926576119246002856000611de8565b505b611931600085611e28565b6119725760405162461bcd60e51b815260206004820152601260248201527119985a5b1959081d1bc8185919081c1bdbdb60721b6044820152606401610468565b6040516001600160a01b03851681527fbadad752e47b51d72487f7881b9baa7c0ed207b8d84f37c0e23eb0a6d67e5b1590602001610ceb565b6000610f9d8383611e3d565b6000610f9d836001600160a01b038416611e67565b60006119da6012600a6125b9565b6119e48385612694565b610f9d91906126ab565b6000610304825490565b6000808080611a078686611ed7565b9097909650945050505050565b6000611a216002836119b7565b905080600003611a2f575050565b611a3b6012600a6125b9565b8103611a825760405162461bcd60e51b815260206004820152601660248201527518d85b89dd081c995b5bdd99481b185cdd081c1bdbdb60521b6044820152606401610468565b6000611aba611a926002856119b7565b611a9e6012600a6125b9565b611aa891906125d8565b611ab46012600a6125b9565b90611dcf565b90506000611ac860006119ee565b9050611ad76002856000611de8565b50836001600160a01b03167f49175c3467edeba7662e939bf84305eaf5084072855b0560f6ac3e145cd172ae6000604051611b1491815260200190565b60405180910390a26000611b296001836125d8565b67ffffffffffffffff811115611b4157611b4161212f565b604051908082528060200260200182016040528015611b6a578160200160208202803683370190505b5090506000611b7a6001846125d8565b67ffffffffffffffff811115611b9257611b9261212f565b604051908082528060200260200182016040528015611bbb578160200160208202803683370190505b5090506000805b84811015611c69576000611bd681836119ab565b90506000611be56002836119b7565b905080600003611bf6575050611c57565b81868581518110611c0957611c096124a9565b60200260200101906001600160a01b031690816001600160a01b03168152505080858581518110611c3c57611c3c6124a9565b602090810291909101015283611c51816125eb565b94505050505b80611c61816125eb565b915050611bc2565b506000805b82811015611d60576000858281518110611c8a57611c8a6124a9565b602002602001015190506000611cc289878581518110611cac57611cac6124a9565b60200260200101516119cc90919063ffffffff16565b9050611ccf6001866125d8565b8303611cef5783611ce26012600a6125b9565b611cec91906125d8565b90505b611cf981856125c5565b9350611d0760028383611de8565b50816001600160a01b03167f49175c3467edeba7662e939bf84305eaf5084072855b0560f6ac3e145cd172ae82604051611d4391815260200190565b60405180910390a250508080611d58906125eb565b915050611c6e565b505050505050505050565b6001600160a01b03811660009081526001830160205260408120541515610f9d565b6000610f9d836001600160a01b038416611f02565b6000610f9d836001600160a01b038416611ff5565b600081831015611dc957828203610f9d565b50900390565b600081611dde6012600a6125b9565b6119e49085612694565b6000611dfe846001600160a01b03851684612012565b949350505050565b60606000610f9d8361202f565b6000610f9d836001600160a01b03841661208b565b6000610f9d836001600160a01b038416612097565b6000826000018281548110611e5457611e546124a9565b9060005260206000200154905092915050565b600081815260028301602052604081205480151580611e8b5750611e8b848461208b565b610f9d5760405162461bcd60e51b815260206004820152601e60248201527f456e756d657261626c654d61703a206e6f6e6578697374656e74206b657900006044820152606401610468565b60008080611ee585856119ab565b600081815260029690960160205260409095205494959350505050565b60008181526001830160205260408120548015611feb576000611f266001836125d8565b8554909150600090611f3a906001906125d8565b9050818114611f9f576000866000018281548110611f5a57611f5a6124a9565b9060005260206000200154905080876000018481548110611f7d57611f7d6124a9565b6000918252602080832090910192909255918252600188019052604090208390555b8554869080611fb057611fb06126ef565b600190038181906000526020600020016000905590558560010160008681526020019081526020016000206000905560019350505050610304565b6000915050610304565b60008181526002830160205260408120819055610f9d83836120e6565b60008281526002840160205260408120829055611dfe84846120f2565b60608160000180548060200260200160405190810160405280929190818152602001828054801561207f57602002820191906000526020600020905b81548152602001906001019080831161206b575b50505050509050919050565b6000610f9d83836120fe565b60008181526001830160205260408120546120de57508154600181810184556000848152602080822090930184905584548482528286019093526040902091909155610304565b506000610304565b6000610f9d8383611f02565b6000610f9d8383612097565b60008181526001830160205260408120541515610f9d565b60006020828403121561212857600080fd5b5035919050565b634e487b7160e01b600052604160045260246000fd5b6040805190810167ffffffffffffffff811182821017156121685761216861212f565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156121975761219761212f565b604052919050565b600067ffffffffffffffff8211156121b9576121b961212f565b5060051b60200190565b600082601f8301126121d457600080fd5b813560206121e96121e48361219f565b61216e565b82815260059290921b8401810191818101908684111561220857600080fd5b8286015b84811015612223578035835291830191830161220c565b509695505050505050565b60008060006060848603121561224357600080fd5b83359250602084013567ffffffffffffffff81111561226157600080fd5b61226d868287016121c3565b925050604084013590509250925092565b602080825282518282018190526000919060409081850190868401855b828110156122c957815180516001600160a01b0316855286015186850152928401929085019060010161229b565b5091979650505050505050565b6001600160a01b038116811461065557600080fd5b6000602082840312156122fd57600080fd5b8135610f9d816122d6565b60008060006060848603121561231d57600080fd5b833567ffffffffffffffff81111561233457600080fd5b612340868287016121c3565b9660208601359650604090950135949350505050565b6000806040838503121561236957600080fd5b82359150602083013567ffffffffffffffff81111561238757600080fd5b612393858286016121c3565b9150509250929050565b600060208083850312156123b057600080fd5b823567ffffffffffffffff8111156123c757600080fd5b8301601f810185136123d857600080fd5b80356123e66121e48261219f565b81815260069190911b8201830190838101908783111561240557600080fd5b928401925b8284101561245157604084890312156124235760008081fd5b61242b612145565b8435612436816122d6565b8152848601358682015282526040909301929084019061240a565b979650505050505050565b6020808252825182820181905260009190848201906040850190845b8181101561249d5783516001600160a01b031683529284019291840191600101612478565b50909695505050505050565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b600181815b808511156125105781600019048211156124f6576124f66124bf565b8085161561250357918102915b93841c93908002906124da565b509250929050565b60008261252757506001610304565b8161253457506000610304565b816001811461254a576002811461255457612570565b6001915050610304565b60ff841115612565576125656124bf565b50506001821b610304565b5060208310610133831016604e8410600b8410161715612593575081810a610304565b61259d83836124d5565b80600019048211156125b1576125b16124bf565b029392505050565b6000610f9d8383612518565b80820180821115610304576103046124bf565b81810381811115610304576103046124bf565b6000600182016125fd576125fd6124bf565b5060010190565b6020808252600e908201526d1b9bdd08185d5d1a1bdc9a5e995960921b604082015260600190565b60006020828403121561263e57600080fd5b8151610f9d816122d6565b60006020828403121561265b57600080fd5b5051919050565b60006020828403121561267457600080fd5b815160ff81168114610f9d57600080fd5b6000610f9d60ff841683612518565b8082028115828204841417610304576103046124bf565b6000826126c857634e487b7160e01b600052601260045260246000fd5b500490565b6000602082840312156126df57600080fd5b81518015158114610f9d57600080fd5b634e487b7160e01b600052603160045260246000fdfea2646970667358221220bbfff24b88d8efa029fa1f79e284862232aa7e6ecab53f8f11c1f365bb31197d64736f6c63430008110033000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000071e1829c1f45e8a02931a4721719b8cd2fd1c5580000000000000000000000002790ec478f150a98f5d96755601a26403df57eae00000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000004e3fbd56cd56c3e72c1403e103b45db9da5b9d2b000000000000000000000000d533a949740bb3306d119cc777fa900ba034cd520000000000000000000000000000000000000000000000000000000000000009436f6e69632045544800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006636e634554480000000000000000000000000000000000000000000000000000

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

000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000071e1829c1f45e8a02931a4721719b8cd2fd1c5580000000000000000000000002790ec478f150a98f5d96755601a26403df57eae00000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000004e3fbd56cd56c3e72c1403e103b45db9da5b9d2b000000000000000000000000d533a949740bb3306d119cc777fa900ba034cd520000000000000000000000000000000000000000000000000000000000000009436f6e69632045544800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006636e634554480000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _underlying (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
Arg [1] : _rewardManager (address): 0x71e1829c1f45e8a02931A4721719b8cD2FD1C558
Arg [2] : _controller (address): 0x2790EC478f150a98F5D96755601a26403DF57EaE
Arg [3] : _lpTokenName (string): Conic ETH
Arg [4] : _symbol (string): cncETH
Arg [5] : _cvx (address): 0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B
Arg [6] : _crv (address): 0xD533a949740bb3306d119CC777fa900bA034cd52

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
Arg [1] : 00000000000000000000000071e1829c1f45e8a02931a4721719b8cd2fd1c558
Arg [2] : 0000000000000000000000002790ec478f150a98f5d96755601a26403df57eae
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [5] : 0000000000000000000000004e3fbd56cd56c3e72c1403e103b45db9da5b9d2b
Arg [6] : 000000000000000000000000d533a949740bb3306d119cc777fa900ba034cd52
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [8] : 436f6e6963204554480000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [10] : 636e634554480000000000000000000000000000000000000000000000000000