Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library DataTypes
• interface IUwuLend
•    - function deposit(
•    - function withdraw(
•    - function borrow(
•    - function repay(
•    - function swapBorrowRateMode(address a ...
•    - function rebalanceStableBorrowRate(ad ...
•    - function setUserUseReserveAsCollatera ...
•    - function liquidationCall(
•    - function flashLoan(
•    - function getUserAccountData(address u ...
•    - function getAddressesProvider()
•    - function initReserve(
•    - function setReserveInterestRateStrate ...
•    - function setConfiguration(address res ...
•    - function getConfiguration(address ass ...
•    - function getUserConfiguration(address ...
•    - function getReserveNormalizedIncome(a ...
•    - function getReserveNormalizedVariable ...
•    - function getReserveData(address asset ...
•    - function finalizeTransfer(
•    - function getReservesList()
•    - function setPause(bool val)
•    - function paused()
• interface IDataProvider
•    - function getReserveConfigurationData( ...
• interface IUwuRewards
•    - function claim(address _user, address ...
•    - function claimableReward(address _use ...
• interface IUwuLocker
•    - function exitEarly(address)
• interface ISwapRouter
•    - function exactInputSingle(ExactInputS ...
•    - function exactInput(ExactInputParams ...
• interface IUniswapV3Factory
•    - function getPool(
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(
•    - function mod(uint256 a, uint256 b)
•    - function mod(
•    - function _msgSender()
•    - function _msgData()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function _functionCallWithValue(
•  contract ERC20 is Context, IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(
•    - function _setupDecimals(uint8 decimal ...
•    - function _beforeTokenTransfer(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
• interface IJar is IERC20
•    - function token()
•    - function reward()
•    - function claimInsurance()
•    - function getRatio()
•    - function depositAll()
•    - function balance()
•    - function deposit(uint256)
•    - function withdrawAll()
•    - function withdraw(uint256)
•    - function earn()
•    - function decimals()
• interface UniswapRouterV2
•    - function swapExactTokensForTokens(
•    - function addLiquidity(
•    - function addLiquidityETH(
•    - function removeLiquidity(
•    - function getAmountsOut(uint256 amount ...
•    - function getAmountsIn(uint256 amountO ...
•    - function swapETHForExactTokens(
•    - function swapExactETHForTokens(
• interface IUniswapV2Pair
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint256 ...
•    - function transferFrom(
•    - function DOMAIN_SEPARATOR()
•    - function PERMIT_TYPEHASH()
•    - function nonces(address owner)
•    - function permit(
•    - function MINIMUM_LIQUIDITY()
•    - function factory()
•    - function token0()
•    - function token1()
•    - function getReserves()
•    - function price0CumulativeLast()
•    - function price1CumulativeLast()
•    - function kLast()
•    - function mint(address to)
•    - function burn(address to)
•    - function swap(
•    - function skim(address to)
•    - function sync()
• interface IUniswapV2Factory
•    - function getPair(address tokenA, addr ...
•    - function allPairs(uint256)
•    - function allPairsLength()
•    - function feeTo()
•    - function feeToSetter()
•    - function createPair(address tokenA, a ...
• interface IController
•    - function jars(address)
•    - function rewards()
•    - function devfund()
•    - function treasury()
•    - function balanceOf(address)
•    - function withdraw(address, uint256)
•    - function withdrawReward(address, uint ...
•    - function earn(address, uint256)
•    - function strategies(address)
•    - function balanceOfWant()
•    - function balanceOfPool()
•    - function balanceOf()
•    - function getName()
•    - function getHarvestable()
•    - function getActiveRewardsTokens()
•    - function whitelistHarvesters(address[ ...
•    - function revokeHarvesters(address[] c ...
•    - function setWithdrawalDevFundFee(uint ...
•    - function setWithdrawalTreasuryFee(uin ...
•    - function setPerformanceDevFee(uint256 ...
•    - function setPerformanceTreasuryFee(ui ...
•    - function setStrategist(address _strat ...
•    - function setGovernance(address _gover ...
•    - function setTimelock(address _timeloc ...
•    - function setController(address _contr ...
•    - function deposit()
•    - function withdraw(IERC20 _asset)
•    - function withdraw(uint256 _amount)
•    - function withdrawForSwap(uint256 _amo ...
•    - function withdrawAll()
•    - function _withdrawAll()
•    - function _withdrawSome(uint256 _amoun ...
•    - function harvest()
•    - function execute(address _target, byt ...
•    - function _swapDefaultWithPath(address ...
•    - function _swapWithPath(
•    - function _distributePerformanceFeesNa ...
•    - function getSupplied()
•    - function getBorrowed()
•    - function balanceOfPool()
•    - function getLeveragedSupplyTarget(uin ...
•    - function getSafeLeverageColFactor()
•    - function getMarketColFactor()
•    - function getMaxLeverage()
•    - function getHarvestable()
•    - function getColFactor()
•    - function getSuppliedUnleveraged()
•    - function getBorrowable()
•    - function getRedeemable()
•    - function getCurrentLeverage()
•    - function setColFactorLeverageBuffer(u ...
•    - function setNativeToTokenPath(bytes m ...
•    - function sync()
•    - function leverageToMax()
•    - function leverageUntil(uint256 _suppl ...
•    - function deleverageToMin()
•    - function deleverageUntil(uint256 _sup ...
•    - function harvest()
•    - function deposit()
•    - function _withdrawSome(uint256 _amoun ...
•  contract StrategyUwuWeth is Strate ... *
•    - function getName()

More Options

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

/**
 *Submitted for verification at Etherscan.io on 2022-09-24
*/

// Sources flattened with hardhat v2.10.1 https://hardhat.org

// File src/interfaces/uwu/data-types.sol

pragma solidity ^0.8.0;

library DataTypes {
    // refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties.
    struct ReserveData {
        //stores the reserve configuration
        ReserveConfigurationMap configuration;
        //the liquidity index. Expressed in ray
        uint128 liquidityIndex;
        //variable borrow index. Expressed in ray
        uint128 variableBorrowIndex;
        //the current supply rate. Expressed in ray
        uint128 currentLiquidityRate;
        //the current variable borrow rate. Expressed in ray
        uint128 currentVariableBorrowRate;
        //the current stable borrow rate. Expressed in ray
        uint128 currentStableBorrowRate;
        uint40 lastUpdateTimestamp;
        //tokens addresses
        address aTokenAddress;
        address stableDebtTokenAddress;
        address variableDebtTokenAddress;
        //address of the interest rate strategy
        address interestRateStrategyAddress;
        //the id of the reserve. Represents the position in the list of the active reserves
        uint8 id;
    }

    struct ReserveConfigurationMap {
        //bit 0-15: LTV
        //bit 16-31: Liq. threshold
        //bit 32-47: Liq. bonus
        //bit 48-55: Decimals
        //bit 56: Reserve is active
        //bit 57: reserve is frozen
        //bit 58: borrowing is enabled
        //bit 59: stable rate borrowing enabled
        //bit 60-63: reserved
        //bit 64-79: reserve factor
        uint256 data;
    }

    struct UserConfigurationMap {
        uint256 data;
    }

    enum InterestRateMode {
        NONE,
        STABLE,
        VARIABLE
    }
}

// File src/interfaces/uwu/uwu-lend.sol
pragma solidity ^0.8.0;

interface IUwuLend {
    /**
     * @dev Emitted on deposit()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address initiating the deposit
     * @param onBehalfOf The beneficiary of the deposit, receiving the aTokens
     * @param amount The amount deposited
     * @param referral The referral code used
     **/
    event Deposit(
        address indexed reserve,
        address user,
        address indexed onBehalfOf,
        uint256 amount,
        uint16 indexed referral
    );

    /**
     * @dev Emitted on withdraw()
     * @param reserve The address of the underlyng asset being withdrawn
     * @param user The address initiating the withdrawal, owner of aTokens
     * @param to Address that will receive the underlying
     * @param amount The amount to be withdrawn
     **/
    event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);

    /**
     * @dev Emitted on borrow() and flashLoan() when debt needs to be opened
     * @param reserve The address of the underlying asset being borrowed
     * @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just
     * initiator of the transaction on flashLoan()
     * @param onBehalfOf The address that will be getting the debt
     * @param amount The amount borrowed out
     * @param borrowRateMode The rate mode: 1 for Stable, 2 for Variable
     * @param borrowRate The numeric rate at which the user has borrowed
     * @param referral The referral code used
     **/
    event Borrow(
        address indexed reserve,
        address user,
        address indexed onBehalfOf,
        uint256 amount,
        uint256 borrowRateMode,
        uint256 borrowRate,
        uint16 indexed referral
    );

    /**
     * @dev Emitted on repay()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The beneficiary of the repayment, getting his debt reduced
     * @param repayer The address of the user initiating the repay(), providing the funds
     * @param amount The amount repaid
     **/
    event Repay(address indexed reserve, address indexed user, address indexed repayer, uint256 amount);

    /**
     * @dev Emitted on swapBorrowRateMode()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address of the user swapping his rate mode
     * @param rateMode The rate mode that the user wants to swap to
     **/
    event Swap(address indexed reserve, address indexed user, uint256 rateMode);

    /**
     * @dev Emitted on setUserUseReserveAsCollateral()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address of the user enabling the usage as collateral
     **/
    event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);

    /**
     * @dev Emitted on setUserUseReserveAsCollateral()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address of the user enabling the usage as collateral
     **/
    event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);

    /**
     * @dev Emitted on rebalanceStableBorrowRate()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address of the user for which the rebalance has been executed
     **/
    event RebalanceStableBorrowRate(address indexed reserve, address indexed user);

    /**
     * @dev Emitted on flashLoan()
     * @param target The address of the flash loan receiver contract
     * @param initiator The address initiating the flash loan
     * @param asset The address of the asset being flash borrowed
     * @param amount The amount flash borrowed
     * @param premium The fee flash borrowed
     * @param referralCode The referral code used
     **/
    event FlashLoan(
        address indexed target,
        address indexed initiator,
        address indexed asset,
        uint256 amount,
        uint256 premium,
        uint16 referralCode
    );

    /**
     * @dev Emitted when the pause is triggered.
     */
    event Paused();

    /**
     * @dev Emitted when the pause is lifted.
     */
    event Unpaused();

    /**
     * @dev Emitted when a borrower is liquidated. This event is emitted by the LendingPool via
     * LendingPoolCollateral manager using a DELEGATECALL
     * This allows to have the events in the generated ABI for LendingPool.
     * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
     * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
     * @param user The address of the borrower getting liquidated
     * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
     * @param liquidatedCollateralAmount The amount of collateral received by the liiquidator
     * @param liquidator The address of the liquidator
     * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
     * to receive the underlying collateral asset directly
     **/
    event LiquidationCall(
        address indexed collateralAsset,
        address indexed debtAsset,
        address indexed user,
        uint256 debtToCover,
        uint256 liquidatedCollateralAmount,
        address liquidator,
        bool receiveAToken
    );

    /**
     * @dev Emitted when the state of a reserve is updated. NOTE: This event is actually declared
     * in the ReserveLogic library and emitted in the updateInterestRates() function. Since the function is internal,
     * the event will actually be fired by the LendingPool contract. The event is therefore replicated here so it
     * gets added to the LendingPool ABI
     * @param reserve The address of the underlying asset of the reserve
     * @param liquidityRate The new liquidity rate
     * @param stableBorrowRate The new stable borrow rate
     * @param variableBorrowRate The new variable borrow rate
     * @param liquidityIndex The new liquidity index
     * @param variableBorrowIndex The new variable borrow index
     **/
    event ReserveDataUpdated(
        address indexed reserve,
        uint256 liquidityRate,
        uint256 stableBorrowRate,
        uint256 variableBorrowRate,
        uint256 liquidityIndex,
        uint256 variableBorrowIndex
    );

    /**
     * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
     * - E.g. User deposits 100 USDC and gets in return 100 aUSDC
     * @param asset The address of the underlying asset to deposit
     * @param amount The amount to be deposited
     * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
     *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
     *   is a different wallet
     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     **/
    function deposit(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode
    ) external;

    /**
     * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
     * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
     * @param asset The address of the underlying asset to withdraw
     * @param amount The underlying amount to be withdrawn
     *   - Send the value type(uint256).max in order to withdraw the whole aToken balance
     * @param to Address that will receive the underlying, same as msg.sender if the user
     *   wants to receive it on his own wallet, or a different address if the beneficiary is a
     *   different wallet
     * @return The final amount withdrawn
     **/
    function withdraw(
        address asset,
        uint256 amount,
        address to
    ) external returns (uint256);

    /**
     * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
     * already deposited enough collateral, or he was given enough allowance by a credit delegator on the
     * corresponding debt token (StableDebtToken or VariableDebtToken)
     * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
     *   and 100 stable/variable debt tokens, depending on the `interestRateMode`
     * @param asset The address of the underlying asset to borrow
     * @param amount The amount to be borrowed
     * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
     * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
     * if he has been given credit delegation allowance
     **/
    function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        uint16 referralCode,
        address onBehalfOf
    ) external;

    /**
     * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
     * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
     * @param asset The address of the borrowed underlying asset previously borrowed
     * @param amount The amount to repay
     * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
     * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
     * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
     * user calling the function if he wants to reduce/remove his own debt, or the address of any other
     * other borrower whose debt should be removed
     * @return The final amount repaid
     **/
    function repay(
        address asset,
        uint256 amount,
        uint256 rateMode,
        address onBehalfOf
    ) external returns (uint256);

    /**
     * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
     * @param asset The address of the underlying asset borrowed
     * @param rateMode The rate mode that the user wants to swap to
     **/
    function swapBorrowRateMode(address asset, uint256 rateMode) external;

    /**
     * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
     * - Users can be rebalanced if the following conditions are satisfied:
     *     1. Usage ratio is above 95%
     *     2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
     *        borrowed at a stable rate and depositors are not earning enough
     * @param asset The address of the underlying asset borrowed
     * @param user The address of the user to be rebalanced
     **/
    function rebalanceStableBorrowRate(address asset, address user) external;

    /**
     * @dev Allows depositors to enable/disable a specific deposited asset as collateral
     * @param asset The address of the underlying asset deposited
     * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
     **/
    function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;

    /**
     * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
     * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
     *   a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
     * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
     * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
     * @param user The address of the borrower getting liquidated
     * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
     * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
     * to receive the underlying collateral asset directly
     **/
    function liquidationCall(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover,
        bool receiveAToken
    ) external;

    /**
     * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
     * as long as the amount taken plus a fee is returned.
     * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
     * For further details please visit https://developers.aave.com
     * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
     * @param assets The addresses of the assets being flash-borrowed
     * @param amounts The amounts amounts being flash-borrowed
     * @param modes Types of the debt to open if the flash loan is not returned:
     *   0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
     *   1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
     *   2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
     * @param onBehalfOf The address  that will receive the debt in the case of using on `modes` 1 or 2
     * @param params Variadic packed params to pass to the receiver as extra information
     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     **/
    function flashLoan(
        address receiverAddress,
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata modes,
        address onBehalfOf,
        bytes calldata params,
        uint16 referralCode
    ) external;

    /**
     * @dev Returns the user account data across all the reserves
     * @param user The address of the user
     * @return totalCollateralETH the total collateral in ETH of the user
     * @return totalDebtETH the total debt in ETH of the user
     * @return availableBorrowsETH the borrowing power left of the user
     * @return currentLiquidationThreshold the liquidation threshold of the user
     * @return ltv the loan to value of the user
     * @return healthFactor the current health factor of the user
     **/
    function getUserAccountData(address user)
        external
        view
        returns (
            uint256 totalCollateralETH,
            uint256 totalDebtETH,
            uint256 availableBorrowsETH,
            uint256 currentLiquidationThreshold,
            uint256 ltv,
            uint256 healthFactor
        );

    function getAddressesProvider() external view returns (address);

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

    function setReserveInterestRateStrategyAddress(address reserve, address rateStrategyAddress) external;

    function setConfiguration(address reserve, uint256 configuration) external;

    /**
     * @dev Returns the configuration of the reserve
     * @param asset The address of the underlying asset of the reserve
     * @return The configuration of the reserve
     **/
    function getConfiguration(address asset) external view returns (DataTypes.ReserveConfigurationMap memory);

    /**
     * @dev Returns the configuration of the user across all the reserves
     * @param user The user address
     * @return The configuration of the user
     **/
    function getUserConfiguration(address user) external view returns (DataTypes.UserConfigurationMap memory);

    /**
     * @dev Returns the normalized income normalized income of the reserve
     * @param asset The address of the underlying asset of the reserve
     * @return The reserve's normalized income
     */
    function getReserveNormalizedIncome(address asset) external view returns (uint256);

    /**
     * @dev Returns the normalized variable debt per unit of asset
     * @param asset The address of the underlying asset of the reserve
     * @return The reserve normalized variable debt
     */
    function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);

    /**
     * @dev Returns the state and configuration of the reserve
     * @param asset The address of the underlying asset of the reserve
     * @return The state of the reserve
     **/
    function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);

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

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

    function setPause(bool val) external;

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

// File src/interfaces/uwu/data-provider.sol

pragma solidity ^0.8.0;

interface IDataProvider {
    function getReserveConfigurationData(address asset)
        external
        view
        returns (
            uint256 decimals,
            uint256 ltv,
            uint256 liquidationThreshold,
            uint256 liquidationBonus,
            uint256 reserveFactor,
            bool usageAsCollateralEnabled,
            bool borrowingEnabled,
            bool stableBorrowRateEnabled,
            bool isActive,
            bool isFrozen
        );
}

// File src/interfaces/uwu/uwu-rewards.sol

pragma solidity ^0.8.0;

interface IUwuRewards {
    function claim(address _user, address[] calldata _tokens) external;

    function claimableReward(address _user, address[] calldata _tokens) external view returns (uint256[] memory);
}

interface IUwuLocker {
    function exitEarly(address) external;
}

// File src/interfaces/univ3/ISwapRouter.sol

pragma solidity >=0.6.7;
pragma experimental ABIEncoderV2;

interface ISwapRouter {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }

    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);

    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
}

interface IUniswapV3Factory {
    function getPool(
        address tokenA,
        address tokenB,
        uint24 fee
    ) external view returns (address pool);
}

// File src/lib/safe-math.sol

pragma solidity >=0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

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

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

// File src/lib/context.sol

pragma solidity >=0.6.0;

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

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

// File src/lib/erc20.sol

// File: contracts/GSN/Context.sol

pragma solidity >=0.6.0;

// File: contracts/token/ERC20/IERC20.sol

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

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

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

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

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

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

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

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

// File: contracts/utils/Address.sol

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

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

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

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

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

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

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

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

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: contracts/token/ERC20/ERC20.sol

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

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(sender, recipient, amount);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File src/interfaces/jar.sol

pragma solidity >=0.6.2;

interface IJar is IERC20 {
    function token() external view returns (address);

    function reward() external view returns (address);

    function claimInsurance() external; // NOTE: Only yDelegatedVault implements this

    function getRatio() external view returns (uint256);

    function depositAll() external;

    function balance() external view returns (uint256);

    function deposit(uint256) external;

    function withdrawAll() external;

    function withdraw(uint256) external;

    function earn() external;

    function decimals() external view returns (uint8);
}

// File src/interfaces/uniswapv2.sol

pragma solidity >=0.6.2;

interface UniswapRouterV2 {
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);
}

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

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

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

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

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

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

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

    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (
            uint112 reserve0,
            uint112 reserve1,
            uint32 blockTimestampLast
        );

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to) external returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;
}

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);

    function getPair(address tokenA, address tokenB) external view returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function createPair(address tokenA, address tokenB) external returns (address pair);
}

// File src/interfaces/controller.sol

pragma solidity >=0.6.0;

interface IController {
    function jars(address) external view returns (address);

    function rewards() external view returns (address);

    function devfund() external view returns (address);

    function treasury() external view returns (address);

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

    function withdraw(address, uint256) external;

    function withdrawReward(address, uint256) external;

    function earn(address, uint256) external;

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

// File src/strategies/strategy-base-v2.sol

pragma solidity >=0.8.6;

// Strategy Contract Basics

abstract contract StrategyBase {
    using SafeERC20 for IERC20;
    using Address for address;
    using SafeMath for uint256;

    // Perfomance fees - start with 20%
    uint256 public performanceTreasuryFee = 2000;
    uint256 public constant performanceTreasuryMax = 10000;

    uint256 public performanceDevFee = 0;
    uint256 public constant performanceDevMax = 10000;

    // Withdrawal fee 0%
    // - 0% to treasury
    // - 0% to dev fund
    uint256 public withdrawalTreasuryFee = 0;
    uint256 public constant withdrawalTreasuryMax = 100000;

    uint256 public withdrawalDevFundFee = 0;
    uint256 public constant withdrawalDevFundMax = 100000;

    // Tokens
    address public want;
    address public constant weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    address public constant native = weth;

    // User accounts
    address public governance;
    address public controller;
    address public strategist;
    address public timelock;

    // Dex
    address public constant uniV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    address public constant univ3Router = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
    address public constant sushiRouter = 0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F;

    mapping(address => bool) public harvesters;
    address[] public activeRewardsTokens;

    constructor(
        address _want,
        address _governance,
        address _strategist,
        address _controller,
        address _timelock
    ) {
        require(_want != address(0));
        require(_governance != address(0));
        require(_strategist != address(0));
        require(_controller != address(0));
        require(_timelock != address(0));

        want = _want;
        governance = _governance;
        strategist = _strategist;
        controller = _controller;
        timelock = _timelock;
    }

    // **** Modifiers **** //

    modifier onlyBenevolent() {
        require(harvesters[msg.sender] || msg.sender == governance || msg.sender == strategist);
        _;
    }

    // **** Views **** //

    function balanceOfWant() public view returns (uint256) {
        return IERC20(want).balanceOf(address(this));
    }

    function balanceOfPool() public view virtual returns (uint256) {}

    function balanceOf() public view returns (uint256) {
        return balanceOfWant().add(balanceOfPool());
    }

    function getName() external pure virtual returns (string memory);

    function getHarvestable() external view virtual returns (uint256);

    function getActiveRewardsTokens() external view returns (address[] memory) {
        return activeRewardsTokens;
    }

    // **** Setters **** //

    function whitelistHarvesters(address[] calldata _harvesters) external {
        require(msg.sender == governance || msg.sender == strategist || harvesters[msg.sender], "not authorized");

        for (uint256 i = 0; i < _harvesters.length; i++) {
            harvesters[_harvesters[i]] = true;
        }
    }

    function revokeHarvesters(address[] calldata _harvesters) external {
        require(msg.sender == governance || msg.sender == strategist, "not authorized");

        for (uint256 i = 0; i < _harvesters.length; i++) {
            harvesters[_harvesters[i]] = false;
        }
    }

    function setWithdrawalDevFundFee(uint256 _withdrawalDevFundFee) external {
        require(msg.sender == timelock, "!timelock");
        withdrawalDevFundFee = _withdrawalDevFundFee;
    }

    function setWithdrawalTreasuryFee(uint256 _withdrawalTreasuryFee) external {
        require(msg.sender == timelock, "!timelock");
        withdrawalTreasuryFee = _withdrawalTreasuryFee;
    }

    function setPerformanceDevFee(uint256 _performanceDevFee) external {
        require(msg.sender == timelock, "!timelock");
        performanceDevFee = _performanceDevFee;
    }

    function setPerformanceTreasuryFee(uint256 _performanceTreasuryFee) external {
        require(msg.sender == timelock, "!timelock");
        performanceTreasuryFee = _performanceTreasuryFee;
    }

    function setStrategist(address _strategist) external {
        require(msg.sender == governance, "!governance");
        strategist = _strategist;
    }

    function setGovernance(address _governance) external {
        require(msg.sender == governance, "!governance");
        governance = _governance;
    }

    function setTimelock(address _timelock) external {
        require(msg.sender == timelock, "!timelock");
        timelock = _timelock;
    }

    function setController(address _controller) external {
        require(msg.sender == timelock, "!timelock");
        controller = _controller;
    }

    // **** State mutations **** //
    function deposit() public virtual;

    // Controller only function for creating additional rewards from dust
    function withdraw(IERC20 _asset) external returns (uint256 balance) {
        require(msg.sender == controller, "!controller");
        require(want != address(_asset), "want");
        balance = _asset.balanceOf(address(this));
        _asset.safeTransfer(controller, balance);
    }

    // Withdraw partial funds, normally used with a jar withdrawal
    function withdraw(uint256 _amount) external {
        require(msg.sender == controller, "!controller");
        uint256 _balance = IERC20(want).balanceOf(address(this));
        if (_balance < _amount) {
            _amount = _withdrawSome(_amount.sub(_balance));
            _amount = _amount.add(_balance);
        }

        uint256 _feeDev = _amount.mul(withdrawalDevFundFee).div(withdrawalDevFundMax);
        IERC20(want).safeTransfer(IController(controller).devfund(), _feeDev);

        uint256 _feeTreasury = _amount.mul(withdrawalTreasuryFee).div(withdrawalTreasuryMax);
        IERC20(want).safeTransfer(IController(controller).treasury(), _feeTreasury);

        address _jar = IController(controller).jars(address(want));
        require(_jar != address(0), "!jar"); // additional protection so we don't burn the funds

        IERC20(want).safeTransfer(_jar, _amount.sub(_feeDev).sub(_feeTreasury));
    }

    // Withdraw funds, used to swap between strategies
    function withdrawForSwap(uint256 _amount) external returns (uint256 balance) {
        require(msg.sender == controller, "!controller");
        _withdrawSome(_amount);

        balance = IERC20(want).balanceOf(address(this));

        address _jar = IController(controller).jars(address(want));
        require(_jar != address(0), "!jar");
        IERC20(want).safeTransfer(_jar, balance);
    }

    // Withdraw all funds, normally used when migrating strategies
    function withdrawAll() external returns (uint256 balance) {
        require(msg.sender == controller, "!controller");
        _withdrawAll();

        balance = IERC20(want).balanceOf(address(this));

        address _jar = IController(controller).jars(address(want));
        require(_jar != address(0), "!jar"); // additional protection so we don't burn the funds
        IERC20(want).safeTransfer(_jar, balance);
    }

    function _withdrawAll() internal {
        _withdrawSome(balanceOfPool());
    }

    function _withdrawSome(uint256 _amount) internal virtual returns (uint256);

    function harvest() public virtual;

    // **** Emergency functions ****

    function execute(address _target, bytes memory _data) public payable returns (bytes memory response) {
        require(msg.sender == timelock, "!timelock");
        require(_target != address(0), "!target");

        // call contract in current context
        assembly {
            let succeeded := delegatecall(sub(gas(), 5000), _target, add(_data, 0x20), mload(_data), 0, 0)
            let size := returndatasize()

            response := mload(0x40)
            mstore(0x40, add(response, and(add(add(size, 0x20), 0x1f), not(0x1f))))
            mstore(response, size)
            returndatacopy(add(response, 0x20), 0, size)

            switch iszero(succeeded)
            case 1 {
                // throw if delegatecall failed
                revert(add(response, 0x20), size)
            }
        }
    }

    function _swapDefaultWithPath(address[] memory path, uint256 _amount) internal {
        require(path[1] != address(0));
        UniswapRouterV2(uniV2Router).swapExactTokensForTokens(_amount, 0, path, address(this), block.timestamp.add(60));
    }

    function _swapWithPath(
        address router,
        address[] memory path,
        uint256 _amount
    ) internal {
        require(path[1] != address(0));
        UniswapRouterV2(router).swapExactTokensForTokens(_amount, 0, path, address(this), block.timestamp.add(60));
    }

    function _distributePerformanceFeesNative() internal {
        uint256 _native = IERC20(native).balanceOf(address(this));
        if (_native > 0) {
            // Treasury fees
            IERC20(native).safeTransfer(
                IController(controller).treasury(),
                _native.mul(performanceTreasuryFee).div(performanceTreasuryMax)
            );
        }
    }
}

// File src/strategies/uwu/strategy-uwu-base.sol

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.6;

abstract contract StrategyUwuBase is StrategyBase {
    using SafeERC20 for IERC20;
    using Address for address;
    using SafeMath for uint256;

    address public constant uwu = 0x55C08ca52497e2f1534B59E2917BF524D4765257;
    address public constant lendingPool = 0x2409aF0251DCB89EE3Dee572629291f9B087c668;
    address public constant dataProviderAddr = 0x17938eDE656Ca1901807abf43a6B1D138D8Cd521;

    address public immutable aToken;
    address public immutable variableDebtToken;

    IUwuRewards uwuRewards = IUwuRewards(0x21953192664867e19F85E96E1D1Dd79dc31cCcdB);

    IUwuLocker uwuLocker = IUwuLocker(0x7c0bF1108935e7105E218BBB4f670E5942c5e237);
    IDataProvider dataProvider;

    bytes nativeToTokenPath;

    // Require a 0.04 buffer between
    // market collateral factor and strategy's collateral factor
    // when leveraging.
    uint256 colFactorLeverageBuffer = 40;
    uint256 colFactorLeverageBufferMax = 1000;

    constructor(
        address _token,
        bytes memory _path,
        address _governance,
        address _strategist,
        address _controller,
        address _timelock
    ) StrategyBase(_token, _governance, _strategist, _controller, _timelock) {
        nativeToTokenPath = _path;

        DataTypes.ReserveData memory reserveData = IUwuLend(lendingPool).getReserveData(_token);
        aToken = reserveData.aTokenAddress;
        variableDebtToken = reserveData.variableDebtTokenAddress;
        dataProvider = IDataProvider(dataProviderAddr);

        IERC20(weth).approve(univ3Router, type(uint256).max);
    }

    // **** Modifiers **** //

    modifier onlyKeepers() {
        require(
            harvesters[msg.sender] ||
                msg.sender == address(this) ||
                msg.sender == strategist ||
                msg.sender == governance,
            "!keepers"
        );
        _;
    }

    function getSupplied() public view returns (uint256) {
        return IERC20(aToken).balanceOf(address(this));
    }

    function getBorrowed() public view returns (uint256) {
        return IERC20(variableDebtToken).balanceOf(address(this));
    }

    function balanceOfPool() public view override returns (uint256) {
        uint256 supplied = getSupplied();
        uint256 borrowed = getBorrowed();
        return supplied.sub(borrowed);
    }

    // Given an unleveraged supply balance, return the target
    // leveraged supply balance which is still within the safety buffer
    function getLeveragedSupplyTarget(uint256 supplyBalance) public view returns (uint256) {
        uint256 leverage = getMaxLeverage();
        return supplyBalance.mul(leverage).div(1e18);
    }

    function getSafeLeverageColFactor() public view returns (uint256) {
        uint256 colFactor = getMarketColFactor();

        // Collateral factor within the buffer
        uint256 safeColFactor = colFactor.sub(colFactorLeverageBuffer.mul(1e18).div(colFactorLeverageBufferMax));

        return safeColFactor;
    }

    function getMarketColFactor() public view returns (uint256) {
        (, uint256 ltv, , , , , , , , ) = dataProvider.getReserveConfigurationData(want);

        // Scale to 18 decimal places, Aave denominates by 10000
        return ltv.mul(1e14);
    }

    // Max leverage we can go up to, w.r.t safe buffer
    function getMaxLeverage() public view returns (uint256) {
        uint256 safeLeverageColFactor = getSafeLeverageColFactor();

        // Infinite geometric series
        uint256 leverage = uint256(1e36).div(1e18 - safeLeverageColFactor);
        return leverage;
    }

    function getHarvestable() external view override returns (uint256) {
        address[] memory aTokens = new address[](1);
        aTokens[0] = aToken;
        uint256[] memory rewards = uwuRewards.claimableReward(address(this), aTokens);

        return rewards[0].div(2);
    }

    function getColFactor() public view returns (uint256) {
        uint256 supplied = getSupplied();
        uint256 borrowed = getBorrowed();

        return borrowed.mul(1e18).div(supplied);
    }

    function getSuppliedUnleveraged() public view returns (uint256) {
        uint256 supplied = getSupplied();
        uint256 borrowed = getBorrowed();

        return supplied.sub(borrowed);
    }

    function getBorrowable() public view returns (uint256) {
        uint256 supplied = getSupplied();
        uint256 borrowed = getBorrowed();
        uint256 marketColFactor = getMarketColFactor();

        // 99.99% just in case some dust accumulates
        return supplied.mul(marketColFactor).div(1e18).sub(borrowed).mul(9999).div(10000);
    }

    function getRedeemable() public view returns (uint256) {
        uint256 supplied = getSupplied();
        uint256 borrowed = getBorrowed();
        uint256 marketColFactor = getMarketColFactor();

        // Return 99.99% of the time just incase
        return supplied.sub(borrowed.mul(1e18).div(marketColFactor)).mul(9999).div(10000);
    }

    function getCurrentLeverage() public view returns (uint256) {
        uint256 supplied = getSupplied();
        uint256 borrowed = getBorrowed();

        return supplied.mul(1e18).div(supplied.sub(borrowed));
    }

    function setColFactorLeverageBuffer(uint256 _colFactorLeverageBuffer) public {
        require(msg.sender == governance || msg.sender == strategist, "!governance");
        colFactorLeverageBuffer = _colFactorLeverageBuffer;
    }

    function setNativeToTokenPath(bytes memory _path) public {
        require(msg.sender == governance || msg.sender == timelock, "!governance");
        nativeToTokenPath = _path;
    }

    // **** State mutations **** //

    // Do a `callStatic` on this.
    // If it returns true then run it for realz. (i.e. eth_signedTx, not eth_call)
    function sync() public returns (bool) {
        uint256 colFactor = getColFactor();
        uint256 safeLeverageColFactor = getSafeLeverageColFactor();

        // If we're not safe
        if (colFactor > safeLeverageColFactor) {
            uint256 unleveragedSupply = getSuppliedUnleveraged();
            uint256 idealSupply = getLeveragedSupplyTarget(unleveragedSupply);

            deleverageUntil(idealSupply);

            return true;
        }

        return false;
    }

    function leverageToMax() public {
        uint256 unleveragedSupply = getSuppliedUnleveraged();
        uint256 idealSupply = getLeveragedSupplyTarget(unleveragedSupply);
        leverageUntil(idealSupply);
    }

    // Leverages until we're supplying <x> amount
    // 1. Redeem <x> DAI
    // 2. Repay <x> DAI
    function leverageUntil(uint256 _supplyAmount) public onlyKeepers {
        // 1. Borrow out <X> DAI
        // 2. Supply <X> DAI

        uint256 leverage = getMaxLeverage();
        uint256 unleveragedSupply = getSuppliedUnleveraged();
        require(
            _supplyAmount >= unleveragedSupply && _supplyAmount <= unleveragedSupply.mul(leverage).div(1e18),
            "!leverage"
        );

        // Since we're only leveraging one asset
        // Supplied = borrowed
        uint256 _borrowAndSupply;
        uint256 supplied = getSupplied();
        while (supplied < _supplyAmount) {
            _borrowAndSupply = getBorrowable();

            if (supplied.add(_borrowAndSupply) > _supplyAmount) {
                _borrowAndSupply = _supplyAmount.sub(supplied);
            }

            IUwuLend(lendingPool).borrow(
                want,
                _borrowAndSupply,
                uint256(DataTypes.InterestRateMode.VARIABLE),
                0,
                address(this)
            );
            deposit();

            supplied = supplied.add(_borrowAndSupply);
        }
    }

    function deleverageToMin() public {
        uint256 unleveragedSupply = getSuppliedUnleveraged();
        deleverageUntil(unleveragedSupply);
    }

    // Deleverages until we're supplying <x> amount
    // 1. Redeem <x> DAI
    // 2. Repay <x> DAI
    function deleverageUntil(uint256 _supplyAmount) public onlyKeepers {
        uint256 unleveragedSupply = getSuppliedUnleveraged();
        uint256 supplied = getSupplied();
        require(_supplyAmount >= unleveragedSupply && _supplyAmount <= supplied, "!deleverage");

        // Market collateral factor
        uint256 marketColFactor = getMarketColFactor();

        // How much can we redeem
        uint256 _redeemAndRepay = getRedeemable();
        while (supplied > _supplyAmount) {
            // If the amount we're redeeming is exceeding the
            // target supplyAmount, adjust accordingly
            if (supplied.sub(_redeemAndRepay) < _supplyAmount) {
                _redeemAndRepay = supplied.sub(_supplyAmount);
            }

            // withdraw
            require(IUwuLend(lendingPool).withdraw(want, _redeemAndRepay, address(this)) != 0, "!withdraw");

            IERC20(want).safeApprove(lendingPool, 0);
            IERC20(want).safeApprove(lendingPool, _redeemAndRepay);

            // repay
            require(
                IUwuLend(lendingPool).repay(
                    want,
                    _redeemAndRepay,
                    uint256(DataTypes.InterestRateMode.VARIABLE),
                    address(this)
                ) != 0,
                "!repay"
            );

            supplied = supplied.sub(_redeemAndRepay);

            // After each deleverage we can redeem more (the colFactor)
            _redeemAndRepay = _redeemAndRepay.mul(1e18).div(marketColFactor);
        }
    }

    function harvest() public override onlyBenevolent {
        address[] memory aTokens = new address[](1);
        aTokens[0] = aToken;

        uwuRewards.claim(address(this), aTokens);
        uwuLocker.exitEarly(address(this));

        uint256 _uwu = IERC20(uwu).balanceOf(address(this));
        if (_uwu > 0) {
            // First swap to ETH on Sushi, then ETH -> want on UniV3
            IERC20(uwu).safeApprove(sushiRouter, 0);
            IERC20(uwu).safeApprove(sushiRouter, _uwu);
            address[] memory path = new address[](2);
            path[0] = uwu;
            path[1] = weth;

            _swapWithPath(sushiRouter, path, _uwu);

            _distributePerformanceFeesNative();

            uint256 _weth = IERC20(weth).balanceOf(address(this));

            if (nativeToTokenPath.length > 0)
                ISwapRouter(univ3Router).exactInput(
                    ISwapRouter.ExactInputParams({
                        path: nativeToTokenPath,
                        recipient: address(this),
                        deadline: block.timestamp + 300,
                        amountIn: _weth,
                        amountOutMinimum: 0
                    })
                );

            deposit();
        }
    }

    function deposit() public override {
        uint256 _want = IERC20(want).balanceOf(address(this));
        if (_want > 0) {
            IERC20(want).safeApprove(lendingPool, 0);
            IERC20(want).safeApprove(lendingPool, _want);
            IUwuLend(lendingPool).deposit(want, _want, address(this), 0);
        }
    }

    function _withdrawSome(uint256 _amount) internal override returns (uint256) {
        uint256 _want = balanceOfWant();
        if (_want < _amount) {
            uint256 _redeem = _amount.sub(_want);

            // How much borrowed amount do we need to free?
            uint256 borrowed = getBorrowed();
            uint256 supplied = getSupplied();
            uint256 curLeverage = getCurrentLeverage();
            uint256 borrowedToBeFree = _redeem.mul(curLeverage).div(1e18);

            // If the amount we need to free is > borrowed
            // Just free up all the borrowed amount
            if (borrowedToBeFree > borrowed) {
                this.deleverageToMin();
            } else {
                // Otherwise just keep freeing up borrowed amounts until
                // we hit a safe number to redeem our underlying
                this.deleverageUntil(supplied.sub(borrowedToBeFree));
            }

            // withdraw
            require(IUwuLend(lendingPool).withdraw(want, _redeem, address(this)) != 0, "!withdraw");
        }

        return _amount;
    }
}

// File src/strategies/uwu/strategy-uwu-weth.sol

pragma solidity >=0.8.6;

contract StrategyUwuWeth is StrategyUwuBase {
    bytes path = "";

    constructor(
        address _governance,
        address _strategist,
        address _controller,
        address _timelock
    ) StrategyUwuBase(weth, path, _governance, _strategist, _controller, _timelock) {}

    // **** Views ****

    function getName() external pure override returns (string memory) {
        return "StrategyUwuWeth";
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_governance","type":"address"},{"internalType":"address","name":"_strategist","type":"address"},{"internalType":"address","name":"_controller","type":"address"},{"internalType":"address","name":"_timelock","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"aToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"activeRewardsTokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfWant","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dataProviderAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deleverageToMin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_supplyAmount","type":"uint256"}],"name":"deleverageUntil","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_target","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"execute","outputs":[{"internalType":"bytes","name":"response","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getActiveRewardsTokens","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBorrowable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBorrowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getColFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentLeverage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getHarvestable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"supplyBalance","type":"uint256"}],"name":"getLeveragedSupplyTarget","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMarketColFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxLeverage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getRedeemable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSafeLeverageColFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSupplied","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSuppliedUnleveraged","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"harvesters","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lendingPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"leverageToMax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_supplyAmount","type":"uint256"}],"name":"leverageUntil","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"native","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceDevFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceDevMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceTreasuryFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceTreasuryMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_harvesters","type":"address[]"}],"name":"revokeHarvesters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_colFactorLeverageBuffer","type":"uint256"}],"name":"setColFactorLeverageBuffer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_controller","type":"address"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_governance","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_path","type":"bytes"}],"name":"setNativeToTokenPath","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceDevFee","type":"uint256"}],"name":"setPerformanceDevFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceTreasuryFee","type":"uint256"}],"name":"setPerformanceTreasuryFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_strategist","type":"address"}],"name":"setStrategist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_timelock","type":"address"}],"name":"setTimelock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawalDevFundFee","type":"uint256"}],"name":"setWithdrawalDevFundFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawalTreasuryFee","type":"uint256"}],"name":"setWithdrawalTreasuryFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"strategist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sushiRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sync","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"timelock","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniV2Router","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"univ3Router","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uwu","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"variableDebtToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"want","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_harvesters","type":"address[]"}],"name":"whitelistHarvesters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_asset","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawForSwap","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawalDevFundFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalDevFundMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalTreasuryFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalTreasuryMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000009d074e37d408542fd38be78848e8814afb38db17000000000000000000000000acfe4511ce883c14c4ea40563f176c3c09b4c47c0000000000000000000000006847259b2b3a4c17e7c43c54409810af48ba5210000000000000000000000000d92c7faa0ca0e6ae4918f3a83d9832d9caeaa0d3

-----Decoded View---------------
Arg [0] : _governance (address): 0x9d074E37d408542FD38be78848e8814AFB38db17
Arg [1] : _strategist (address): 0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C
Arg [2] : _controller (address): 0x6847259b2B3A4c17e7c43C54409810aF48bA5210
Arg [3] : _timelock (address): 0xD92c7fAa0Ca0e6AE4918f3a83d9832d9CAEAA0d3

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000009d074e37d408542fd38be78848e8814afb38db17
Arg [1] : 000000000000000000000000acfe4511ce883c14c4ea40563f176c3c09b4c47c
Arg [2] : 0000000000000000000000006847259b2b3a4c17e7c43c54409810af48ba5210
Arg [3] : 000000000000000000000000d92c7faa0ca0e6ae4918f3a83d9832d9caeaa0d3

81494:438:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72574:284;;;;;;;;;;;;;:::i;:::-;;;16977:25:1;;;16965:2;16950:18;72574:284:0;;;;;;;;62085:120;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;62244:315::-;;;;;;;;;;-1:-1:-1;62244:315:0;;;;;:::i;:::-;;:::i;:::-;;72290:276;;;;;;;;;;;;;:::i;71091:198::-;;;;;;;;;;;;;:::i;60284:37::-;;;;;;;;;;;;60235:42;60284:37;;;;;-1:-1:-1;;;;;6436:32:1;;;6418:51;;6406:2;6391:18;60284:37:0;6272:203:1;81820:109:0;;;;;;;;;;-1:-1:-1;81897:24:0;;;;;;;;;;;;-1:-1:-1;;;81897:24:0;;;;81820:109;;;;;;;:::i;66988:839::-;;;;;;:::i;:::-;;:::i;60178:19::-;;;;;;;;;;-1:-1:-1;60178:19:0;;;;-1:-1:-1;;;;;60178:19:0;;;60416:25;;;;;;;;;;-1:-1:-1;60416:25:0;;;;-1:-1:-1;;;;;60416:25:0;;;63451:199;;;;;;;;;;-1:-1:-1;63451:199:0;;;;;:::i;:::-;;:::i;59705:54::-;;;;;;;;;;;;59754:5;59705:54;;72866:200;;;;;;;;;;;;;:::i;64813:937::-;;;;;;;;;;-1:-1:-1;64813:937:0;;;;;:::i;:::-;;:::i;74230:233::-;;;;;;;;;;-1:-1:-1;74230:233:0;;;;;:::i;:::-;;:::i;71637:323::-;;;;;;;;;;;;;:::i;60579:80::-;;;;;;;;;;;;60617:42;60579:80;;71968:258;;;;;;;;;;;;;:::i;78660:1280::-;;;;;;;;;;;;;:::i;60101:53::-;;;;;;;;;;;;60148:6;60101:53;;60804:36;;;;;;;;;;-1:-1:-1;60804:36:0;;;;;:::i;:::-;;:::i;69056:72::-;;;;;;;;;;;;69086:42;69056:72;;64448:289;;;;;;;;;;-1:-1:-1;64448:289:0;;;;;:::i;:::-;;:::i;60055:39::-;;;;;;;;;;;;;;;;59654:44;;;;;;;;;;;;;;;;60352:25;;;;;;;;;;-1:-1:-1;60352:25:0;;;;-1:-1:-1;;;;;60352:25:0;;;74002:220;;;;;;;;;;;;;:::i;70828:118::-;;;;;;;;;;;;;:::i;60666:80::-;;;;;;;;;;;;60704:42;60666:80;;61817:113;;;;;;;;;;;;;:::i;70954:129::-;;;;;;;;;;;;;:::i;63061:195::-;;;;;;;;;;-1:-1:-1;63061:195:0;;;;;:::i;:::-;;:::i;66295:430::-;;;;;;;;;;;;;:::i;73644:350::-;;;;;;;;;;;;;:::i;60755:42::-;;;;;;;;;;-1:-1:-1;60755:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;9710:14:1;;9703:22;9685:41;;9673:2;9658:18;60755:42:0;9545:187:1;59768:36:0;;;;;;;;;;;;;;;;59945:40;;;;;;;;;;;;;;;;69354:42;;;;;;;;;;;;;;;64135:151;;;;;;;;;;-1:-1:-1;64135:151:0;;;;;:::i;:::-;;:::i;60492:80::-;;;;;;;;;;;;60530:42;60492:80;;73282:354;;;;;;;;;;;;;:::i;69316:31::-;;;;;;;;;;;;;;;71433:196;;;;;;;;;;-1:-1:-1;71433:196:0;;;;;:::i;:::-;;:::i;69135:80::-;;;;;;;;;;;;69173:42;69135:80;;63821:155;;;;;;;;;;-1:-1:-1;63821:155:0;;;;;:::i;:::-;;:::i;62862:191::-;;;;;;;;;;-1:-1:-1;62862:191:0;;;;;:::i;:::-;;:::i;75329:216::-;;;;;;;;;;;;;:::i;62567:287::-;;;;;;;;;;-1:-1:-1;62567:287:0;;;;;:::i;:::-;;:::i;63984:143::-;;;;;;;;;;-1:-1:-1;63984:143:0;;;;;:::i;:::-;;:::i;61618:118::-;;;;;;;;;;;;;:::i;65814:405::-;;;;;;;;;;-1:-1:-1;65814:405:0;;;;;:::i;:::-;;:::i;63264:179::-;;;;;;;;;;-1:-1:-1;63264:179:0;;;;;:::i;:::-;;:::i;63658:155::-;;;;;;;;;;-1:-1:-1;63658:155:0;;;;;:::i;:::-;;:::i;79948:333::-;;;;;;;;;;;;;:::i;60448:23::-;;;;;;;;;;-1:-1:-1;60448:23:0;;;;-1:-1:-1;;;;;60448:23:0;;;69222:85;;;;;;;;;;;;69265:42;69222:85;;74471:186;;;;;;;;;;-1:-1:-1;74471:186:0;;;;;:::i;:::-;;:::i;77069:1583::-;;;;;;;;;;-1:-1:-1;77069:1583:0;;;;;:::i;:::-;;:::i;75655:1144::-;;;;;;;;;;-1:-1:-1;75655:1144:0;;;;;:::i;:::-;;:::i;76807:150::-;;;;;;;;;;;;;:::i;60384:25::-;;;;;;;;;;-1:-1:-1;60384:25:0;;;;-1:-1:-1;;;;;60384:25:0;;;74823:498;;;;;;;;;;;;;:::i;72574:284::-;72679:16;;;72693:1;72679:16;;;;;;;;;72632:7;;;;72679:16;;;;;;;;;;;;-1:-1:-1;72679:16:0;72652:43;;72719:6;72706:7;72714:1;72706:10;;;;;;;;:::i;:::-;-1:-1:-1;;;;;72706:19:0;;;:10;;;;;;;;;:19;72763:10;;:50;;-1:-1:-1;;;72763:50:0;;72736:24;;72763:10;;;;;:26;;:50;;72798:4;;72805:7;;72763:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;72763:50:0;;;;;;;;;;;;:::i;:::-;72736:77;;72833:17;72848:1;72833:7;72841:1;72833:10;;;;;;;;:::i;:::-;;;;;;;:14;;:17;;;;:::i;:::-;72826:24;;;;72574:284;:::o;62085:120::-;62142:16;62178:19;62171:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;62171:26:0;;;;;;;;;;;;;;;;;;;;;;;62085:120;:::o;62244:315::-;62347:10;;-1:-1:-1;;;;;62347:10:0;62333;:24;;:52;;-1:-1:-1;62375:10:0;;-1:-1:-1;;;;;62375:10:0;62361;:24;62333:52;:78;;;-1:-1:-1;62400:10:0;62389:22;;;;:10;:22;;;;;;;;62333:78;62325:105;;;;-1:-1:-1;;;62325:105:0;;13435:2:1;62325:105:0;;;13417:21:1;13474:2;13454:18;;;13447:30;-1:-1:-1;;;13493:18:1;;;13486:44;13547:18;;62325:105:0;;;;;;;;;62448:9;62443:109;62463:22;;;62443:109;;;62536:4;62507:10;:26;62518:11;;62530:1;62518:14;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;62507:26:0;;;;;;;;;;;;-1:-1:-1;62507:26:0;:33;;-1:-1:-1;;62507:33:0;;;;;;;;;;62487:3;;;;:::i;:::-;;;;62443:109;;;;62244:315;;:::o;72290:276::-;72337:7;72357:29;72389:26;:24;:26::i;:::-;72357:58;-1:-1:-1;72466:16:0;72485:47;72503:28;72357:58;72503:4;:28;:::i;:::-;72493:4;;72485:17;:47::i;:::-;72466:66;72290:276;-1:-1:-1;;;72290:276:0:o;71091:198::-;71146:7;71166:16;71185:13;:11;:13::i;:::-;71166:32;;71209:16;71228:13;:11;:13::i;:::-;71209:32;-1:-1:-1;71259:22:0;:8;71209:32;71259:12;:22::i;66988:839::-;67122:8;;67066:21;;-1:-1:-1;;;;;67122:8:0;67108:10;:22;67100:44;;;;-1:-1:-1;;;67100:44:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;67163:21:0;;67155:41;;;;-1:-1:-1;;;67155:41:0;;10725:2:1;67155:41:0;;;10707:21:1;10764:1;10744:18;;;10737:29;-1:-1:-1;;;10782:18:1;;;10775:37;10829:18;;67155:41:0;10523:330:1;67155:41:0;67370:1;67367;67359:5;67353:12;67346:4;67339:5;67335:16;67326:7;67319:4;67312:5;67308:16;67295:77;67398:16;67448:4;67442:11;67430:23;;67530:4;67526:9;67519:4;67512;67506;67502:15;67498:26;67494:42;67484:8;67480:57;67474:4;67467:71;67569:4;67559:8;67552:22;67627:4;67624:1;67617:4;67607:8;67603:19;67588:44;67662:9;67655:17;67691:1;67686:123;;;;67648:161;;67686:123;67789:4;67782;67772:8;67768:19;67761:33;67648:161;;;;66988:839;;;;:::o;63451:199::-;63561:8;;-1:-1:-1;;;;;63561:8:0;63547:10;:22;63539:44;;;;-1:-1:-1;;;63539:44:0;;;;;;;:::i;:::-;63594:22;:48;63451:199::o;72866:200::-;72911:7;72931:16;72950:13;:11;:13::i;:::-;72931:32;;72974:16;72993:13;:11;:13::i;:::-;72974:32;-1:-1:-1;73026:32:0;73049:8;73026:18;72974:32;73039:4;73026:12;:18::i;:::-;:22;;:32::i;64813:937::-;64890:10;;-1:-1:-1;;;;;64890:10:0;64876;:24;64868:48;;;;-1:-1:-1;;;64868:48:0;;;;;;;:::i;:::-;64953:4;;;64946:37;;-1:-1:-1;;;64946:37:0;;64977:4;64946:37;;;6418:51:1;;;;64927:16:0;;-1:-1:-1;;;;;64953:4:0;;;;64946:22;;6391:18:1;;64946:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64927:56;;65009:7;64998:8;:18;64994:143;;;65043:36;65057:21;:7;65069:8;65057:11;:21::i;:::-;65043:13;:36::i;:::-;65033:46;-1:-1:-1;65104:21:0;65033:46;65116:8;65104:11;:21::i;:::-;65094:31;;64994:143;65149:15;65167:59;60148:6;65167:33;65179:20;;65167:7;:11;;:33;;;;:::i;:59::-;65149:77;;65237:69;65275:10;;;;;;;;;-1:-1:-1;;;;;65275:10:0;-1:-1:-1;;;;;65263:31:0;;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65244:4;;-1:-1:-1;;;;;65244:4:0;;65298:7;65237:25;:69::i;:::-;65319:20;65342:61;60040:6;65342:34;65354:21;;65342:7;:11;;:34;;;;:::i;:61::-;65319:84;;65414:75;65452:10;;;;;;;;;-1:-1:-1;;;;;65452:10:0;-1:-1:-1;;;;;65440:32:0;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65414:75;65529:10;;65554:4;;;65517:43;;-1:-1:-1;;;65517:43:0;;-1:-1:-1;;;;;65554:4:0;;;65517:43;;;6418:51:1;;;;65502:12:0;;65529:10;;65517:28;;6391:18:1;;65517:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65502:58;-1:-1:-1;;;;;;65579:18:0;;65571:35;;;;-1:-1:-1;;;65571:35:0;;;;;;;:::i;:::-;65671:71;65697:4;65703:38;65728:12;65703:20;:7;65715;65703:11;:20::i;:::-;:24;;:38::i;:::-;65678:4;;-1:-1:-1;;;;;65678:4:0;;65671:71;:25;:71::i;:::-;64857:893;;;;64813:937;:::o;74230:233::-;74340:10;;-1:-1:-1;;;;;74340:10:0;74326;:24;;:52;;-1:-1:-1;74368:10:0;;-1:-1:-1;;;;;74368:10:0;74354;:24;74326:52;74318:76;;;;-1:-1:-1;;;74318:76:0;;;;;;;:::i;:::-;74405:23;:50;74230:233::o;71637:323::-;71694:7;71714:17;71734:20;:18;:20::i;:::-;71714:40;;71815:21;71839:80;71853:65;71891:26;;71853:33;71881:4;71853:23;;:27;;:33;;;;:::i;:65::-;71839:9;;:13;:80::i;71968:258::-;72073:12;;72114:4;;;72073:46;;-1:-1:-1;;;72073:46:0;;-1:-1:-1;;;;;72114:4:0;;;72073:46;;;6418:51:1;;;;72019:7:0;;;;72073:12;;;:40;;6391:18:1;;72073:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72039:80;;;;;;;;;;;72205:13;72213:4;72205:3;:7;;:13;;;;:::i;:::-;72198:20;;;71968:258;:::o;78660:1280::-;61493:10;61482:22;;;;:10;:22;;;;;;;;;:50;;-1:-1:-1;61522:10:0;;-1:-1:-1;;;;;61522:10:0;61508;:24;61482:50;:78;;;-1:-1:-1;61550:10:0;;-1:-1:-1;;;;;61550:10:0;61536;:24;61482:78;61474:87;;;;;;78748:16:::1;::::0;;78762:1:::1;78748:16:::0;;;;;::::1;::::0;;;78721:24:::1;::::0;78748:16:::1;::::0;;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;78748:16:0::1;78721:43;;78788:6;78775:7;78783:1;78775:10;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;78775:19:0;;::::1;:10;::::0;;::::1;::::0;;;;;:19;78807:10:::1;::::0;:40:::1;::::0;-1:-1:-1;;;78807:40:0;;:10;::::1;::::0;:16:::1;::::0;:40:::1;::::0;78832:4:::1;::::0;78839:7;;78807:40:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;78858:9:0::1;::::0;:34:::1;::::0;-1:-1:-1;;;78858:34:0;;78886:4:::1;78858:34;::::0;::::1;6418:51:1::0;-1:-1:-1;;;;;78858:9:0;;::::1;::::0;-1:-1:-1;78858:19:0::1;::::0;-1:-1:-1;6391:18:1;;78858:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;78920:36:0::1;::::0;-1:-1:-1;;;78920:36:0;;78950:4:::1;78920:36;::::0;::::1;6418:51:1::0;78905:12:0::1;::::0;-1:-1:-1;69086:42:0::1;::::0;-1:-1:-1;78920:21:0::1;::::0;6391:18:1;;78920:36:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78905:51:::0;-1:-1:-1;78971:8:0;;78967:966:::1;;79066:39;69086:42;60704;79103:1;79066:23;:39::i;:::-;79120:42;69086;60704;79157:4:::0;79120:23:::1;:42::i;:::-;79201:16;::::0;;79215:1:::1;79201:16:::0;;;;;::::1;::::0;;79177:21:::1;::::0;79201:16:::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;79201:16:0::1;79177:40;;69086:42;79232:4;79237:1;79232:7;;;;;;;;:::i;:::-;;;;;;:13;-1:-1:-1::0;;;;;79232:13:0::1;;;-1:-1:-1::0;;;;;79232:13:0::1;;;::::0;::::1;60235:42;79260:4;79265:1;79260:7;;;;;;;;:::i;:::-;;;;;;:14;-1:-1:-1::0;;;;;79260:14:0::1;;;-1:-1:-1::0;;;;;79260:14:0::1;;;::::0;::::1;79291:38;60704:42;79318:4;79324;79291:13;:38::i;:::-;79346:34;:32;:34::i;:::-;79413:37;::::0;-1:-1:-1;;;79413:37:0;;79444:4:::1;79413:37;::::0;::::1;6418:51:1::0;79397:13:0::1;::::0;60235:42:::1;::::0;79413:22:::1;::::0;6391:18:1;;79413:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79397:53;;79498:1;79471:17;:24;;;;;:::i;:::-;;;:28;79467:428;;;60617:42;-1:-1:-1::0;;;;;79518:35:0::1;;79576:300;;;;;;;;79638:17;79576:300;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;79576:300:0;;;-1:-1:-1;;79701:4:0::1;79576:300;::::0;::::1;::::0;;;79743:21:::1;:15;79761:3;79743:21;:::i;:::-;79576:300;;;;79801:5;79576:300;;;;79851:1;79576:300;;::::0;79518:377:::1;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;79467:428;79912:9;:7;:9::i;:::-;78981:952;;78967:966;78710:1230;;78660:1280::o:0;60804:36::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;60804:36:0;;-1:-1:-1;60804:36:0;:::o;64448:289::-;64549:10;;64499:15;;-1:-1:-1;;;;;64549:10:0;64535;:24;64527:48;;;;-1:-1:-1;;;64527:48:0;;;;;;;:::i;:::-;64594:4;;-1:-1:-1;;;;;64594:23:0;;;:4;;:23;;64586:40;;;;-1:-1:-1;;;64586:40:0;;;;;;12763:2:1;12745:21;;;12802:1;12782:18;;;12775:29;-1:-1:-1;;;12835:2:1;12820:18;;12813:34;12879:2;12864:18;;12561:327;64586:40:0;64647:31;;-1:-1:-1;;;64647:31:0;;64672:4;64647:31;;;6418:51:1;-1:-1:-1;;;;;64647:16:0;;;;;6391:18:1;;64647:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64709:10;;64637:41;;-1:-1:-1;64689:40:0;;-1:-1:-1;;;;;64689:19:0;;;;64709:10;64637:41;64689:19;:40::i;:::-;64448:289;;;:::o;74002:220::-;74053:7;74073:16;74092:13;:11;:13::i;:::-;74073:32;;74116:16;74135:13;:11;:13::i;:::-;74116:32;-1:-1:-1;74168:46:0;74191:22;:8;74116:32;74191:12;:22::i;:::-;74168:18;:8;74181:4;74168:12;:18::i;70828:118::-;70899:39;;-1:-1:-1;;;70899:39:0;;70932:4;70899:39;;;6418:51:1;70872:7:0;;70906:6;-1:-1:-1;;;;;70899:24:0;;;;6391:18:1;;70899:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70892:46;;70828:118;:::o;61817:113::-;61859:7;61886:36;61906:15;:13;:15::i;:::-;61886;:13;:15::i;:::-;:19;;:36::i;70954:129::-;71025:50;;-1:-1:-1;;;71025:50:0;;71069:4;71025:50;;;6418:51:1;70998:7:0;;71032:17;-1:-1:-1;;;;;71025:35:0;;;;6391:18:1;;71025:50:0;6272:203:1;63061:195:0;63169:8;;-1:-1:-1;;;;;63169:8:0;63155:10;:22;63147:44;;;;-1:-1:-1;;;63147:44:0;;;;;;;:::i;:::-;63202:21;:46;63061:195::o;66295:430::-;66386:10;;66336:15;;-1:-1:-1;;;;;66386:10:0;66372;:24;66364:48;;;;-1:-1:-1;;;66364:48:0;;;;;;;:::i;:::-;66423:14;:12;:14::i;:::-;66467:4;;;66460:37;;-1:-1:-1;;;66460:37:0;;66491:4;66460:37;;;6418:51:1;;;;-1:-1:-1;;;;;66467:4:0;;66460:22;;6391:18:1;;66460:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66537:10;;66562:4;;;66525:43;;-1:-1:-1;;;66525:43:0;;-1:-1:-1;;;;;66562:4:0;;;66525:43;;;6418:51:1;;;;66450:47:0;;-1:-1:-1;66510:12:0;;66537:10;;;;66525:28;;6391:18:1;;66525:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66510:58;-1:-1:-1;;;;;;66587:18:0;;66579:35;;;;-1:-1:-1;;;66579:35:0;;;;;;;:::i;:::-;66684:4;;66677:40;;-1:-1:-1;;;;;66684:4:0;66703;66709:7;66677:25;:40::i;:::-;66353:372;66295:430;:::o;73644:350::-;73690:7;73710:16;73729:13;:11;:13::i;:::-;73710:32;;73753:16;73772:13;:11;:13::i;:::-;73753:32;;73796:23;73822:20;:18;:20::i;:::-;73796:46;-1:-1:-1;73912:74:0;73980:5;73912:63;73970:4;73912:53;73925:39;73796:46;73912:63;73925:8;73938:4;73925:12;:18::i;:39::-;73912:8;;:12;:53::i;:::-;:57;;:63::i;:74::-;73905:81;;;;;73644:350;:::o;64135:151::-;64221:8;;-1:-1:-1;;;;;64221:8:0;64207:10;:22;64199:44;;;;-1:-1:-1;;;64199:44:0;;;;;;;:::i;:::-;64254:10;:24;;-1:-1:-1;;;;;;64254:24:0;-1:-1:-1;;;;;64254:24:0;;;;;;;;;;64135:151::o;73282:354::-;73328:7;73348:16;73367:13;:11;:13::i;:::-;73348:32;;73391:16;73410:13;:11;:13::i;:::-;73391:32;;73434:23;73460:20;:18;:20::i;:::-;73434:46;-1:-1:-1;73554:74:0;73622:5;73554:63;73612:4;73554:53;73598:8;73554:39;73588:4;73554:63;:8;73434:46;73554:12;:29::i;71433:196::-;71511:7;71531:16;71550;:14;:16::i;:::-;71531:35;-1:-1:-1;71584:37:0;71616:4;71584:27;:13;71531:35;71584:17;:27::i;63821:155::-;63907:10;;-1:-1:-1;;;;;63907:10:0;63893;:24;63885:48;;;;-1:-1:-1;;;63885:48:0;;;;;;;:::i;:::-;63944:10;:24;;-1:-1:-1;;;;;;63944:24:0;-1:-1:-1;;;;;63944:24:0;;;;;;;;;;63821:155::o;62862:191::-;62968:8;;-1:-1:-1;;;;;62968:8:0;62954:10;:22;62946:44;;;;-1:-1:-1;;;62946:44:0;;;;;;;:::i;:::-;63001:20;:44;62862:191::o;75329:216::-;75372:25;75400:24;:22;:24::i;:::-;75372:52;;75435:19;75457:43;75482:17;75457:24;:43::i;:::-;75435:65;;75511:26;75525:11;75511:13;:26::i;62567:287::-;62667:10;;-1:-1:-1;;;;;62667:10:0;62653;:24;;:52;;-1:-1:-1;62695:10:0;;-1:-1:-1;;;;;62695:10:0;62681;:24;62653:52;62645:79;;;;-1:-1:-1;;;62645:79:0;;13435:2:1;62645:79:0;;;13417:21:1;13474:2;13454:18;;;13447:30;-1:-1:-1;;;13493:18:1;;;13486:44;13547:18;;62645:79:0;13233:338:1;62645:79:0;62742:9;62737:110;62757:22;;;62737:110;;;62830:5;62801:10;:26;62812:11;;62824:1;62812:14;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;62801:26:0;;;;;;;;;;;;-1:-1:-1;62801:26:0;:34;;-1:-1:-1;;62801:34:0;;;;;;;;;;62781:3;;;;:::i;:::-;;;;62737:110;;63984:143;64066:8;;-1:-1:-1;;;;;64066:8:0;64052:10;:22;64044:44;;;;-1:-1:-1;;;64044:44:0;;;;;;;:::i;:::-;64099:8;:20;;-1:-1:-1;;;;;;64099:20:0;-1:-1:-1;;;;;64099:20:0;;;;;;;;;;63984:143::o;61618:118::-;61698:4;;;61691:37;;-1:-1:-1;;;61691:37:0;;61722:4;61691:37;;;6418:51:1;;;;61664:7:0;;-1:-1:-1;;;;;61698:4:0;;;;61691:22;;6391:18:1;;61691:37:0;6272:203:1;65814:405:0;65924:10;;65874:15;;-1:-1:-1;;;;;65924:10:0;65910;:24;65902:48;;;;-1:-1:-1;;;65902:48:0;;;;;;;:::i;:::-;65961:22;65975:7;65961:13;:22::i;:::-;-1:-1:-1;66013:4:0;;;66006:37;;-1:-1:-1;;;66006:37:0;;66037:4;66006:37;;;6418:51:1;;;;-1:-1:-1;;;;;66013:4:0;;66006:22;;6391:18:1;;66006:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66083:10;;66108:4;;;66071:43;;-1:-1:-1;;;66071:43:0;;-1:-1:-1;;;;;66108:4:0;;;66071:43;;;6418:51:1;;;;65996:47:0;;-1:-1:-1;66056:12:0;;66083:10;;;;66071:28;;6391:18:1;;66071:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66056:58;-1:-1:-1;;;;;;66133:18:0;;66125:35;;;;-1:-1:-1;;;66125:35:0;;;;;;;:::i;:::-;66178:4;;66171:40;;-1:-1:-1;;;;;66178:4:0;66197;66203:7;66171:25;:40::i;:::-;65891:328;65814:405;;;:::o;63264:179::-;63364:8;;-1:-1:-1;;;;;63364:8:0;63350:10;:22;63342:44;;;;-1:-1:-1;;;63342:44:0;;;;;;;:::i;:::-;63397:17;:38;63264:179::o;63658:155::-;63744:10;;-1:-1:-1;;;;;63744:10:0;63730;:24;63722:48;;;;-1:-1:-1;;;63722:48:0;;;;;;;:::i;:::-;63781:10;:24;;-1:-1:-1;;;;;;63781:24:0;-1:-1:-1;;;;;63781:24:0;;;;;;;;;;63658:155::o;79948:333::-;80017:4;;;80010:37;;-1:-1:-1;;;80010:37:0;;80041:4;80010:37;;;6418:51:1;;;;79994:13:0;;-1:-1:-1;;;;;80017:4:0;;;;80010:22;;6391:18:1;;80010:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79994:53;-1:-1:-1;80062:9:0;;80058:216;;80095:4;;80088:40;;-1:-1:-1;;;;;80095:4:0;69173:42;80126:1;80088:24;:40::i;:::-;80150:4;;80143:44;;-1:-1:-1;;;;;80150:4:0;69173:42;80181:5;80143:24;:44::i;:::-;80232:4;;;80202:60;;-1:-1:-1;;;80202:60:0;;-1:-1:-1;;;;;80232:4:0;;;80202:60;;;8087:34:1;;;;8137:18;;;8130:34;;;80253:4:0;8180:18:1;;;8173:43;80232:4:0;8232:18:1;;;8225:47;69173:42:0;;80202:29;;8021:19:1;;80202:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80058:216;79983:298;79948:333::o;74471:186::-;74561:10;;-1:-1:-1;;;;;74561:10:0;74547;:24;;:50;;-1:-1:-1;74589:8:0;;-1:-1:-1;;;;;74589:8:0;74575:10;:22;74547:50;74539:74;;;;-1:-1:-1;;;74539:74:0;;;;;;;:::i;:::-;74624:25;;;;:17;;:25;;;;;:::i;77069:1583::-;70615:10;70604:22;;;;:10;:22;;;;;;;;;:70;;-1:-1:-1;70647:10:0;70669:4;70647:27;70604:70;:115;;;-1:-1:-1;70709:10:0;;-1:-1:-1;;;;;70709:10:0;70695;:24;70604:115;:160;;;-1:-1:-1;70754:10:0;;-1:-1:-1;;;;;70754:10:0;70740;:24;70604:160;70582:218;;;;-1:-1:-1;;;70582:218:0;;12427:2:1;70582:218:0;;;12409:21:1;12466:1;12446:18;;;12439:29;-1:-1:-1;;;12484:18:1;;;12477:38;12532:18;;70582:218:0;12225:331:1;70582:218:0;77147:25:::1;77175:24;:22;:24::i;:::-;77147:52;;77210:16;77229:13;:11;:13::i;:::-;77210:32;;77278:17;77261:13;:34;;:63;;;;;77316:8;77299:13;:25;;77261:63;77253:87;;;::::0;-1:-1:-1;;;77253:87:0;;13095:2:1;77253:87:0::1;::::0;::::1;13077:21:1::0;13134:2;13114:18;;;13107:30;-1:-1:-1;;;13153:18:1;;;13146:41;13204:18;;77253:87:0::1;12893:335:1::0;77253:87:0::1;77390:23;77416:20;:18;:20::i;:::-;77390:46;;77484:23;77510:15;:13;:15::i;:::-;77484:41;;77536:1109;77554:13;77543:8;:24;77536:1109;;;77739:13:::0;77707:29:::1;:8:::0;77720:15;77707:12:::1;:29::i;:::-;:45;77703:131;;;77791:27;:8:::0;77804:13;77791:12:::1;:27::i;:::-;77773:45;;77703:131;77914:4;::::0;;77883:68:::1;::::0;-1:-1:-1;;;77883:68:0;;-1:-1:-1;;;;;77914:4:0;;::::1;77883:68:::0;;::::1;7671:34:1::0;;;;7721:18;;;7714:34;;;77945:4:0::1;7764:18:1::0;;;7757:43;69173:42:0::1;::::0;77883:30:::1;::::0;7606:18:1;;77883:68:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;77875:95;;;::::0;-1:-1:-1;;;77875:95:0;;12090:2:1;77875:95:0::1;::::0;::::1;12072:21:1::0;12129:1;12109:18;;;12102:29;-1:-1:-1;;;12147:18:1;;;12140:39;12196:18;;77875:95:0::1;11888:332:1::0;77875:95:0::1;77994:4;::::0;77987:40:::1;::::0;-1:-1:-1;;;;;77994:4:0::1;69173:42;78025:1;77987:24;:40::i;:::-;78049:4;::::0;78042:54:::1;::::0;-1:-1:-1;;;;;78049:4:0::1;69173:42;78080:15:::0;78042:24:::1;:54::i;:::-;78211:4;::::0;;78161:214:::1;::::0;-1:-1:-1;;;78161:214:0;;-1:-1:-1;;;;;78211:4:0;;::::1;78161:214:::0;;::::1;8552:34:1::0;;;;8602:18;;;8595:34;;;78284:35:0::1;8645:18:1::0;;;8638:34;78351:4:0::1;8688:18:1::0;;;8681:43;69173:42:0::1;::::0;78161:27:::1;::::0;8486:19:1;;78161:214:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78135:287;;;::::0;-1:-1:-1;;;78135:287:0;;11756:2:1;78135:287:0::1;::::0;::::1;11738:21:1::0;11795:1;11775:18;;;11768:29;-1:-1:-1;;;11813:18:1;;;11806:36;11859:18;;78135:287:0::1;11554:329:1::0;78135:287:0::1;78450:29;:8:::0;78463:15;78450:12:::1;:29::i;:::-;78439:40:::0;-1:-1:-1;78587:46:0::1;78617:15:::0;78587:25:::1;:15:::0;78607:4:::1;78587:19;:25::i;:46::-;78569:64;;77536:1109;;75655:1144:::0;70615:10;70604:22;;;;:10;:22;;;;;;;;;:70;;-1:-1:-1;70647:10:0;70669:4;70647:27;70604:70;:115;;;-1:-1:-1;70709:10:0;;-1:-1:-1;;;;;70709:10:0;70695;:24;70604:115;:160;;;-1:-1:-1;70754:10:0;;-1:-1:-1;;;;;70754:10:0;70740;:24;70604:160;70582:218;;;;-1:-1:-1;;;70582:218:0;;12427:2:1;70582:218:0;;;12409:21:1;12466:1;12446:18;;;12439:29;-1:-1:-1;;;12484:18:1;;;12477:38;12532:18;;70582:218:0;12225:331:1;70582:218:0;75797:16:::1;75816;:14;:16::i;:::-;75797:35;;75843:25;75871:24;:22;:24::i;:::-;75843:52;;75945:17;75928:13;:34;;:96;;;;-1:-1:-1::0;75983:41:0::1;76019:4;75983:31;:17:::0;76005:8;75983:21:::1;:31::i;:41::-;75966:13;:58;;75928:96;75906:155;;;::::0;-1:-1:-1;;;75906:155:0;;14512:2:1;75906:155:0::1;::::0;::::1;14494:21:1::0;14551:1;14531:18;;;14524:29;-1:-1:-1;;;14569:18:1;;;14562:39;14618:18;;75906:155:0::1;14310:332:1::0;75906:155:0::1;76156:24;76191:16:::0;76210:13:::1;:11;:13::i;:::-;76191:32;;76234:558;76252:13;76241:8;:24;76234:558;;;76301:15;:13;:15::i;:::-;76282:34:::0;-1:-1:-1;76370:13:0;76337:30:::1;:8:::0;76282:34;76337:12:::1;:30::i;:::-;:46;76333:133;;;76423:27;:13:::0;76441:8;76423:17:::1;:27::i;:::-;76404:46;;76333:133;76529:4;::::0;;76482:216:::1;::::0;-1:-1:-1;;;76482:216:0;;-1:-1:-1;;;;;76529:4:0;;::::1;76482:216:::0;;::::1;9039:34:1::0;;;;9089:18;;;9082:34;;;76595:35:0::1;9132:18:1::0;;;9125:34;-1:-1:-1;9175:18:1;;;9168:47;76678:4:0::1;9231:19:1::0;;;9224:44;69173:42:0::1;::::0;76482:28:::1;::::0;8973:19:1;;76482:216:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;76713:9;:7;:9::i;:::-;76750:30;:8:::0;76763:16;76750:12:::1;:30::i;:::-;76739:41;;76234:558;;76807:150:::0;76852:25;76880:24;:22;:24::i;:::-;76852:52;;76915:34;76931:17;76915:15;:34::i;74823:498::-;74855:4;74872:17;74892:14;:12;:14::i;:::-;74872:34;;74917:29;74949:26;:24;:26::i;:::-;74917:58;;75034:21;75022:9;:33;75018:271;;;75072:25;75100:24;:22;:24::i;:::-;75072:52;;75139:19;75161:43;75186:17;75161:24;:43::i;:::-;75139:65;;75221:28;75237:11;75221:15;:28::i;:::-;75273:4;75266:11;;;;;;74823:498;:::o;75018:271::-;75308:5;75301:12;;;;74823:498;:::o;25382:132::-;25440:7;25467:39;25471:1;25474;25467:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;25460:46;;25382:132;;;;;:::o;23511:136::-;23569:7;23596:43;23600:1;23603;23596:43;;;;;;;;;;;;;;;;;:3;:43::i;24435:471::-;24493:7;24738:6;24734:47;;-1:-1:-1;24768:1:0;24761:8;;24734:47;24793:9;24805:5;24809:1;24805;:5;:::i;:::-;24793:17;-1:-1:-1;24838:1:0;24829:5;24833:1;24793:17;24829:5;:::i;:::-;:10;24821:56;;;;-1:-1:-1;;;24821:56:0;;13778:2:1;24821:56:0;;;13760:21:1;13817:2;13797:18;;;13790:30;13856:34;13836:18;;;13829:62;-1:-1:-1;;;13907:18:1;;;13900:31;13948:19;;24821:56:0;13576:397:1;80289:1118:0;80356:7;80376:13;80392:15;:13;:15::i;:::-;80376:31;;80430:7;80422:5;:15;80418:955;;;80454:15;80472:18;:7;80484:5;80472:11;:18::i;:::-;80454:36;;80568:16;80587:13;:11;:13::i;:::-;80568:32;;80615:16;80634:13;:11;:13::i;:::-;80615:32;;80662:19;80684:20;:18;:20::i;:::-;80662:42;-1:-1:-1;80719:24:0;80746:34;80775:4;80746:24;:7;80662:42;80746:11;:24::i;:34::-;80719:61;;80933:8;80914:16;:27;80910:323;;;80962:4;-1:-1:-1;;;;;80962:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80910:323;;;81165:4;:20;81186:30;:8;81199:16;81186:12;:30::i;:::-;81165:52;;;;;;;;;;;;;16977:25:1;;16965:2;16950:18;;16831:177;81165:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80910:323;81313:4;;;81282:60;;-1:-1:-1;;;81282:60:0;;-1:-1:-1;;;;;81313:4:0;;;81282:60;;;7671:34:1;;;;7721:18;;;7714:34;;;81336:4:0;7764:18:1;;;7757:43;69173:42:0;;81282:30;;7606:18:1;;81282:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;81274:87;;;;-1:-1:-1;;;81274:87:0;;12090:2:1;81274:87:0;;;12072:21:1;12129:1;12109:18;;;12102:29;-1:-1:-1;;;12147:18:1;;;12140:39;12196:18;;81274:87:0;11888:332:1;81274:87:0;80439:934;;;;;80418:955;-1:-1:-1;81392:7:0;;80289:1118;-1:-1:-1;80289:1118:0:o;23047:181::-;23105:7;;23137:5;23141:1;23137;:5;:::i;:::-;23125:17;;23166:1;23161;:6;;23153:46;;;;-1:-1:-1;;;23153:46:0;;11400:2:1;23153:46:0;;;11382:21:1;11439:2;11419:18;;;11412:30;11478:29;11458:18;;;11451:57;11525:18;;23153:46:0;11198:351:1;49379:211:0;49523:58;;-1:-1:-1;;;;;7344:32:1;;49523:58:0;;;7326:51:1;7393:18;;;7386:34;;;49496:86:0;;49516:5;;-1:-1:-1;;;49546:23:0;7299:18:1;;49523:58:0;;;;-1:-1:-1;;49523:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;49523:58:0;-1:-1:-1;;;;;;49523:58:0;;;;;;;;;;49496:19;:86::i;50115:670::-;50533:10;;;50532:62;;-1:-1:-1;50549:39:0;;-1:-1:-1;;;50549:39:0;;50573:4;50549:39;;;6692:34:1;-1:-1:-1;;;;;6762:15:1;;;6742:18;;;6735:43;50549:15:0;;;;;6627:18:1;;50549:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;50532:62;50510:166;;;;-1:-1:-1;;;50510:166:0;;15955:2:1;50510:166:0;;;15937:21:1;15994:2;15974:18;;;15967:30;16033:34;16013:18;;;16006:62;-1:-1:-1;;;16084:18:1;;;16077:52;16146:19;;50510:166:0;15753:418:1;50510:166:0;50714:62;;-1:-1:-1;;;;;7344:32:1;;50714:62:0;;;7326:51:1;7393:18;;;7386:34;;;50687:90:0;;50707:5;;-1:-1:-1;;;50737:22:0;7299:18:1;;50714:62:0;7152:274:1;68093:288:0;68253:1;-1:-1:-1;;;;;68234:21:0;:4;68239:1;68234:7;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;;;;68234:21:0;;;68226:30;;;;;;-1:-1:-1;;;;;68267:48:0;;;68316:7;68325:1;68328:4;68342;68349:23;:15;68369:2;68349:19;:23::i;:::-;68267:106;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;68267:106:0;;;;;;;;;;;;:::i;68389:390::-;68471:39;;-1:-1:-1;;;68471:39:0;;68504:4;68471:39;;;6418:51:1;68453:15:0;;60235:42;;68471:24;;6391:18:1;;68471:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68453:57;-1:-1:-1;68525:11:0;;68521:251;;68641:10;;68629:34;;;-1:-1:-1;;;68629:34:0;;;;68583:177;;-1:-1:-1;;;;;68641:10:0;;68629:32;;:34;;;;;;;;;;;;;;68641:10;68629:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68682:63;59754:5;68682:35;68694:22;;68682:7;:11;;:35;;;;:::i;:63::-;60235:42;;68583:177;:27;:177::i;66733:82::-;66777:30;66791:15;:13;:15::i;26010:312::-;26130:7;26165:12;26158:5;26150:28;;;;-1:-1:-1;;;26150:28:0;;;;;;;;:::i;:::-;-1:-1:-1;26189:9:0;26201:5;26205:1;26201;:5;:::i;:::-;26189:17;26010:312;-1:-1:-1;;;;;26010:312:0:o;23950:226::-;24070:7;24106:12;24098:6;;;;24090:29;;;;-1:-1:-1;;;24090:29:0;;;;;;;;:::i;:::-;-1:-1:-1;24130:9:0;24142:5;24146:1;24142;:5;:::i;51914:774::-;52338:23;52364:69;52392:4;52364:69;;;;;;;;;;;;;;;;;52372:5;-1:-1:-1;;;;;52364:27:0;;;:69;;;;;:::i;:::-;52448:17;;52338:95;;-1:-1:-1;52448:21:0;52444:237;;52603:10;52592:30;;;;;;;;;;;;:::i;:::-;52584:85;;;;-1:-1:-1;;;52584:85:0;;15207:2:1;52584:85:0;;;15189:21:1;15246:2;15226:18;;;15219:30;15285:34;15265:18;;;15258:62;-1:-1:-1;;;15336:18:1;;;15329:40;15386:19;;52584:85:0;15005:406:1;35122:230:0;35259:12;35291:53;35314:6;35322:4;35328:1;35331:12;35291:22;:53::i;:::-;35284:60;35122:230;-1:-1:-1;;;;35122:230:0:o;36610:1020::-;36783:12;32562:20;;36808:60;;;;-1:-1:-1;;;36808:60:0;;14849:2:1;36808:60:0;;;14831:21:1;14888:2;14868:18;;;14861:30;14927:31;14907:18;;;14900:59;14976:18;;36808:60:0;14647:353:1;36808:60:0;36942:12;36956:23;36983:6;-1:-1:-1;;;;;36983:11:0;37002:8;37012:4;36983:34;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36941:76;;;;37032:7;37028:595;;;37063:10;-1:-1:-1;37056:17:0;;-1:-1:-1;37056:17:0;37028:595;37177:17;;:21;37173:439;;37440:10;37434:17;37501:15;37488:10;37484:2;37480:19;37473:44;37173:439;37583:12;37576:20;;-1:-1:-1;;;37576:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:164:1;90:13;;139;;132:21;122:32;;112:60;;168:1;165;158:12;183:530;225:5;278:3;271:4;263:6;259:17;255:27;245:55;;296:1;293;286:12;245:55;332:6;319:20;358:18;354:2;351:26;348:52;;;380:18;;:::i;:::-;424:55;467:2;448:13;;-1:-1:-1;;444:27:1;473:4;440:38;424:55;:::i;:::-;504:2;495:7;488:19;550:3;543:4;538:2;530:6;526:15;522:26;519:35;516:55;;;567:1;564;557:12;516:55;632:2;625:4;617:6;613:17;606:4;597:7;593:18;580:55;680:1;655:16;;;673:4;651:27;644:38;;;;659:7;183:530;-1:-1:-1;;;183:530:1:o;718:247::-;777:6;830:2;818:9;809:7;805:23;801:32;798:52;;;846:1;843;836:12;798:52;885:9;872:23;904:31;929:5;904:31;:::i;970:251::-;1040:6;1093:2;1081:9;1072:7;1068:23;1064:32;1061:52;;;1109:1;1106;1099:12;1061:52;1141:9;1135:16;1160:31;1185:5;1160:31;:::i;1226:455::-;1303:6;1311;1364:2;1352:9;1343:7;1339:23;1335:32;1332:52;;;1380:1;1377;1370:12;1332:52;1419:9;1406:23;1438:31;1463:5;1438:31;:::i;:::-;1488:5;-1:-1:-1;1544:2:1;1529:18;;1516:32;1571:18;1560:30;;1557:50;;;1603:1;1600;1593:12;1557:50;1626:49;1667:7;1658:6;1647:9;1643:22;1626:49;:::i;:::-;1616:59;;;1226:455;;;;;:::o;1686:615::-;1772:6;1780;1833:2;1821:9;1812:7;1808:23;1804:32;1801:52;;;1849:1;1846;1839:12;1801:52;1889:9;1876:23;1918:18;1959:2;1951:6;1948:14;1945:34;;;1975:1;1972;1965:12;1945:34;2013:6;2002:9;1998:22;1988:32;;2058:7;2051:4;2047:2;2043:13;2039:27;2029:55;;2080:1;2077;2070:12;2029:55;2120:2;2107:16;2146:2;2138:6;2135:14;2132:34;;;2162:1;2159;2152:12;2132:34;2215:7;2210:2;2200:6;2197:1;2193:14;2189:2;2185:23;2181:32;2178:45;2175:65;;;2236:1;2233;2226:12;2175:65;2267:2;2259:11;;;;;2289:6;;-1:-1:-1;1686:615:1;;-1:-1:-1;;;;1686:615:1:o;2306:947::-;2401:6;2432:2;2475;2463:9;2454:7;2450:23;2446:32;2443:52;;;2491:1;2488;2481:12;2443:52;2524:9;2518:16;2553:18;2594:2;2586:6;2583:14;2580:34;;;2610:1;2607;2600:12;2580:34;2648:6;2637:9;2633:22;2623:32;;2693:7;2686:4;2682:2;2678:13;2674:27;2664:55;;2715:1;2712;2705:12;2664:55;2744:2;2738:9;2766:2;2762;2759:10;2756:36;;;2772:18;;:::i;:::-;2818:2;2815:1;2811:10;2801:20;;2841:28;2865:2;2861;2857:11;2841:28;:::i;:::-;2903:15;;;2934:12;;;;2966:11;;;2996;;;2992:20;;2989:33;-1:-1:-1;2986:53:1;;;3035:1;3032;3025:12;2986:53;3057:1;3048:10;;3067:156;3081:2;3078:1;3075:9;3067:156;;;3138:10;;3126:23;;3099:1;3092:9;;;;;3169:12;;;;3201;;3067:156;;;-1:-1:-1;3242:5:1;2306:947;-1:-1:-1;;;;;;;;2306:947:1:o;3258:202::-;3325:6;3378:2;3366:9;3357:7;3353:23;3349:32;3346:52;;;3394:1;3391;3384:12;3346:52;3417:37;3444:9;3417:37;:::i;3465:320::-;3533:6;3586:2;3574:9;3565:7;3561:23;3557:32;3554:52;;;3602:1;3599;3592:12;3554:52;3642:9;3629:23;3675:18;3667:6;3664:30;3661:50;;;3707:1;3704;3697:12;3661:50;3730:49;3771:7;3762:6;3751:9;3747:22;3730:49;:::i;4056:180::-;4115:6;4168:2;4156:9;4147:7;4143:23;4139:32;4136:52;;;4184:1;4181;4174:12;4136:52;-1:-1:-1;4207:23:1;;4056:180;-1:-1:-1;4056:180:1:o;4241:184::-;4311:6;4364:2;4352:9;4343:7;4339:23;4335:32;4332:52;;;4380:1;4377;4370:12;4332:52;-1:-1:-1;4403:16:1;;4241:184;-1:-1:-1;4241:184:1:o;4430:830::-;4566:6;4574;4582;4590;4598;4606;4614;4622;4630;4638;4691:3;4679:9;4670:7;4666:23;4662:33;4659:53;;;4708:1;4705;4698:12;4659:53;4737:9;4731:16;4721:26;;4787:2;4776:9;4772:18;4766:25;4756:35;;4831:2;4820:9;4816:18;4810:25;4800:35;;4875:2;4864:9;4860:18;4854:25;4844:35;;4919:3;4908:9;4904:19;4898:26;4888:36;;4943:47;4985:3;4974:9;4970:19;4943:47;:::i;:::-;4933:57;;5009:47;5051:3;5040:9;5036:19;5009:47;:::i;:::-;4999:57;;5075:47;5117:3;5106:9;5102:19;5075:47;:::i;:::-;5065:57;;5141:47;5183:3;5172:9;5168:19;5141:47;:::i;:::-;5131:57;;5207:47;5249:3;5238:9;5234:19;5207:47;:::i;:::-;5197:57;;4430:830;;;;;;;;;;;;;:::o;5265:461::-;5318:3;5356:5;5350:12;5383:6;5378:3;5371:19;5409:4;5438:2;5433:3;5429:12;5422:19;;5475:2;5468:5;5464:14;5496:1;5506:195;5520:6;5517:1;5514:13;5506:195;;;5585:13;;-1:-1:-1;;;;;5581:39:1;5569:52;;5641:12;;;;5676:15;;;;5617:1;5535:9;5506:195;;;-1:-1:-1;5717:3:1;;5265:461;-1:-1:-1;;;;;5265:461:1:o;5731:257::-;5772:3;5810:5;5804:12;5837:6;5832:3;5825:19;5853:63;5909:6;5902:4;5897:3;5893:14;5886:4;5879:5;5875:16;5853:63;:::i;:::-;5970:2;5949:15;-1:-1:-1;;5945:29:1;5936:39;;;;5977:4;5932:50;;5731:257;-1:-1:-1;;5731:257:1:o;5993:274::-;6122:3;6160:6;6154:13;6176:53;6222:6;6217:3;6210:4;6202:6;6198:17;6176:53;:::i;:::-;6245:16;;;;;5993:274;-1:-1:-1;;5993:274:1:o;6789:358::-;-1:-1:-1;;;;;6996:32:1;;6978:51;;7065:2;7060;7045:18;;7038:30;;;-1:-1:-1;;7085:56:1;;7122:18;;7114:6;7085:56;:::i;9279:261::-;9458:2;9447:9;9440:21;9421:4;9478:56;9530:2;9519:9;9515:18;9507:6;9478:56;:::i;9737:217::-;9884:2;9873:9;9866:21;9847:4;9904:44;9944:2;9933:9;9929:18;9921:6;9904:44;:::i;10183:335::-;10385:2;10367:21;;;10424:2;10404:18;;;10397:30;-1:-1:-1;;;10458:2:1;10443:18;;10436:41;10509:2;10494:18;;10183:335::o;10858:::-;11060:2;11042:21;;;11099:2;11079:18;;;11072:30;-1:-1:-1;;;11133:2:1;11118:18;;11111:41;11184:2;11169:18;;10858:335::o;13978:327::-;14180:2;14162:21;;;14219:1;14199:18;;;14192:29;-1:-1:-1;;;14252:2:1;14237:18;;14230:34;14296:2;14281:18;;13978:327::o;15416:332::-;15618:2;15600:21;;;15657:1;15637:18;;;15630:29;-1:-1:-1;;;15690:2:1;15675:18;;15668:39;15739:2;15724:18;;15416:332::o;16176:650::-;16371:2;16360:9;16353:21;16334:4;16409:6;16403:13;16452:4;16447:2;16436:9;16432:18;16425:32;16480:51;16526:3;16515:9;16511:19;16497:12;16480:51;:::i;:::-;16466:65;;16612:1;16608;16603:3;16599:11;16595:19;16589:2;16581:6;16577:15;16571:22;16567:48;16562:2;16551:9;16547:18;16540:76;16670:2;16662:6;16658:15;16652:22;16647:2;16636:9;16632:18;16625:50;16730:2;16722:6;16718:15;16712:22;16706:3;16695:9;16691:19;16684:51;16791:3;16783:6;16779:16;16773:23;16766:4;16755:9;16751:20;16744:53;16814:6;16806:14;;;16176:650;;;;:::o;17013:582::-;17312:6;17301:9;17294:25;17355:6;17350:2;17339:9;17335:18;17328:34;17398:3;17393:2;17382:9;17378:18;17371:31;17275:4;17419:57;17471:3;17460:9;17456:19;17448:6;17419:57;:::i;:::-;-1:-1:-1;;;;;17512:32:1;;;;17507:2;17492:18;;17485:60;-1:-1:-1;17576:3:1;17561:19;17554:35;17411:65;17013:582;-1:-1:-1;;;17013:582:1:o;17600:275::-;17671:2;17665:9;17736:2;17717:13;;-1:-1:-1;;17713:27:1;17701:40;;17771:18;17756:34;;17792:22;;;17753:62;17750:88;;;17818:18;;:::i;:::-;17854:2;17847:22;17600:275;;-1:-1:-1;17600:275:1:o;17880:128::-;17920:3;17951:1;17947:6;17944:1;17941:13;17938:39;;;17957:18;;:::i;:::-;-1:-1:-1;17993:9:1;;17880:128::o;18013:217::-;18053:1;18079;18069:132;;18123:10;18118:3;18114:20;18111:1;18104:31;18158:4;18155:1;18148:15;18186:4;18183:1;18176:15;18069:132;-1:-1:-1;18215:9:1;;18013:217::o;18235:168::-;18275:7;18341:1;18337;18333:6;18329:14;18326:1;18323:21;18318:1;18311:9;18304:17;18300:45;18297:71;;;18348:18;;:::i;:::-;-1:-1:-1;18388:9:1;;18235:168::o;18408:125::-;18448:4;18476:1;18473;18470:8;18467:34;;;18481:18;;:::i;:::-;-1:-1:-1;18518:9:1;;18408:125::o;18538:258::-;18610:1;18620:113;18634:6;18631:1;18628:13;18620:113;;;18710:11;;;18704:18;18691:11;;;18684:39;18656:2;18649:10;18620:113;;;18751:6;18748:1;18745:13;18742:48;;;-1:-1:-1;;18786:1:1;18768:16;;18761:27;18538:258::o;18801:380::-;18880:1;18876:12;;;;18923;;;18944:61;;18998:4;18990:6;18986:17;18976:27;;18944:61;19051:2;19043:6;19040:14;19020:18;19017:38;19014:161;;;19097:10;19092:3;19088:20;19085:1;19078:31;19132:4;19129:1;19122:15;19160:4;19157:1;19150:15;19186:135;19225:3;-1:-1:-1;;19246:17:1;;19243:43;;;19266:18;;:::i;:::-;-1:-1:-1;19313:1:1;19302:13;;19186:135::o;19326:127::-;19387:10;19382:3;19378:20;19375:1;19368:31;19418:4;19415:1;19408:15;19442:4;19439:1;19432:15;19590:127;19651:10;19646:3;19642:20;19639:1;19632:31;19682:4;19679:1;19672:15;19706:4;19703:1;19696:15;19722:127;19783:10;19778:3;19774:20;19771:1;19764:31;19814:4;19811:1;19804:15;19838:4;19835:1;19828:15;19854:131;-1:-1:-1;;;;;19929:31:1;;19919:42;;19909:70;;19975:1;19972;19965:12

ipfs://dc2d98799a36442c6c127549e6c6da5d14de35d92aabda25985d4925487f21c1