Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import "./IERC20.sol";
import "./SafeERC20.sol";
import "./IERC721Receiver.sol";
import "./ReentrancyGuard.sol";
import "./EnumerableSet.sol";

import "./INonfungiblePositionManager.sol";

/*
 * Seasonal Token Farm
 *
 * This contract receives donations of seasonal tokens and distributes them to providers of liquidity
 * for the token/MATIC trading pairs on Uniswap v3.
 *
 * Warning: Tokens can be lost if they are not transferred to the farm contract in the correct way.
 *
 * Seasonal tokens must be approved for use by the farm contract and donated using the 
 * receiveSeasonalTokens() function. Tokens sent directly to the farm address will be lost.
 *
 * Contracts that deposit Uniswap liquidity tokens need to implement the onERC721Received() function in order
 * to be able to withdraw those tokens. Any contracts that interact with the farm must be tested prior to 
 * deployment on the main network.
 * 
 * The developers accept no responsibility for tokens irretrievably lost in accidental transfers.
 * 
 */

struct LiquidityToken {
    address owner;
    address seasonalToken;
    uint256 depositTime;
    uint256 initialCumulativeSpringTokensFarmed;
    uint256 initialCumulativeSummerTokensFarmed;
    uint256 initialCumulativeAutumnTokensFarmed;
    uint256 initialCumulativeWinterTokensFarmed;
    uint256 liquidity;
}


contract SeasonalTokenFarm is IERC721Receiver, ReentrancyGuard {

    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.UintSet;

    uint256 public constant REALLOCATION_INTERVAL = (365 * 24 * 60 * 60 * 3) / 4;

    int24 public constant REQUIRED_TICK_UPPER = 887272;
    int24 public constant REQUIRED_TICK_LOWER = -887272;

    uint256 public constant WITHDRAWAL_UNAVAILABLE_DAYS = 30;
    uint256 public constant WITHDRAWAL_AVAILABLE_DAYS = 7;

    mapping(address => uint256) public totalLiquidity;

    mapping(address => EnumerableSet.UintSet) tokenOfOwnerByIndex;
    mapping(uint256 => LiquidityToken) public liquidityTokens;

    address public immutable springTokenAddress;
    address public immutable summerTokenAddress;
    address public immutable autumnTokenAddress;
    address public immutable winterTokenAddress;
    address public immutable wethAddress;

    INonfungiblePositionManager public immutable nonfungiblePositionManager;

    uint256 public immutable startTime;

    mapping(address => mapping(address => uint256)) public cumulativeTokensFarmedPerUnitLiquidity;

    event Deposit(address indexed from, uint256 liquidityTokenId);
    event Withdraw(address indexed tokenOwner, uint256 liquidityTokenId);
    event Donate(address indexed from, address seasonalTokenAddress, uint256 amount);
    event Harvest(address indexed tokenOwner, uint256 liquidityTokenId, 
                  uint256 springAmount, uint256 summerAmount, uint256 autumnAmount, uint256 winterAmount);


    constructor (INonfungiblePositionManager _nonfungiblePositionManager,
                 address _springTokenAddress,
                 address _summerTokenAddress,
                 address _autumnTokenAddress,
                 address _winterTokenAddress,
                 address _wethAddress,
                 uint256 _startTime) {

        require(_startTime < block.timestamp, 'Invalid start time');

        nonfungiblePositionManager = _nonfungiblePositionManager;
        springTokenAddress = _springTokenAddress;
        summerTokenAddress = _summerTokenAddress;
        autumnTokenAddress = _autumnTokenAddress;
        winterTokenAddress = _winterTokenAddress;
        wethAddress = _wethAddress;
        startTime = _startTime;
    }

    function balanceOf(address _liquidityProvider) external view returns (uint256) {
        return tokenOfOwnerByIndex[_liquidityProvider].length();
    }

    function numberOfReAllocations() public view returns (uint256) {
        if (block.timestamp < startTime + REALLOCATION_INTERVAL)
            return 0;
        uint256 timeSinceStart = block.timestamp - startTime;
        return timeSinceStart / REALLOCATION_INTERVAL;
    }

    function hasDoubledAllocation(uint256 _tokenNumber) internal view returns (uint256) {
        return (numberOfReAllocations() % 4 < _tokenNumber) ? 0 : 1;
    }

    function springAllocationSize() public view returns (uint256) {
        return 5 * 2 ** hasDoubledAllocation(1);
    }

    function summerAllocationSize() public view returns (uint256) {
        return 6 * 2 ** hasDoubledAllocation(2);
    }

    function autumnAllocationSize() public view returns (uint256) {
        return 7 * 2 ** hasDoubledAllocation(3);
    }

    function winterAllocationSize() public pure returns (uint256) {
        return 8;
    }

    function getValueFromTokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
        return tokenOfOwnerByIndex[_owner].at(_index);
    }

    function getEffectiveTotalAllocationSize(uint256 _totalSpringLiquidity,
                                             uint256 _totalSummerLiquidity,
                                             uint256 _totalAutumnLiquidity,
                                             uint256 _totalWinterLiquidity) public view returns (uint256) {
        uint256 effectiveTotal = 0;
        if (_totalSpringLiquidity > 0)
            effectiveTotal += springAllocationSize();
        if (_totalSummerLiquidity > 0)
            effectiveTotal += summerAllocationSize();
        if (_totalAutumnLiquidity > 0)
            effectiveTotal += autumnAllocationSize();
        if (_totalWinterLiquidity > 0)
            effectiveTotal += winterAllocationSize();
        return effectiveTotal;
    }

    function allocateIncomingTokensToTradingPairs(address _incomingTokenAddress, uint256 _amount) internal {

        uint256 totalSpringLiquidity = totalLiquidity[springTokenAddress];
        uint256 totalSummerLiquidity = totalLiquidity[summerTokenAddress];
        uint256 totalAutumnLiquidity = totalLiquidity[autumnTokenAddress];
        uint256 totalWinterLiquidity = totalLiquidity[winterTokenAddress];

        uint256 effectiveTotalAllocationSize = getEffectiveTotalAllocationSize(totalSpringLiquidity,
                                                                               totalSummerLiquidity,
                                                                               totalAutumnLiquidity,
                                                                               totalWinterLiquidity);

        require(effectiveTotalAllocationSize > 0, "No liquidity in farm");

        uint256 springPairAllocation = (_amount * springAllocationSize()) / effectiveTotalAllocationSize;
        uint256 summerPairAllocation = (_amount * summerAllocationSize()) / effectiveTotalAllocationSize;
        uint256 autumnPairAllocation = (_amount * autumnAllocationSize()) / effectiveTotalAllocationSize;
        uint256 winterPairAllocation = (_amount * winterAllocationSize()) / effectiveTotalAllocationSize;

        if (totalSpringLiquidity > 0)
            cumulativeTokensFarmedPerUnitLiquidity[springTokenAddress][_incomingTokenAddress]
                += (2 ** 128) * springPairAllocation / totalSpringLiquidity;

        if (totalSummerLiquidity > 0)
            cumulativeTokensFarmedPerUnitLiquidity[summerTokenAddress][_incomingTokenAddress]
                += (2 ** 128) * summerPairAllocation / totalSummerLiquidity;

        if (totalAutumnLiquidity > 0)
            cumulativeTokensFarmedPerUnitLiquidity[autumnTokenAddress][_incomingTokenAddress]
                += (2 ** 128) * autumnPairAllocation / totalAutumnLiquidity;

        if (totalWinterLiquidity > 0)
            cumulativeTokensFarmedPerUnitLiquidity[winterTokenAddress][_incomingTokenAddress]
                += (2 ** 128) * winterPairAllocation / totalWinterLiquidity;
    }

    function receiveSeasonalTokens(address from, address _tokenAddress, uint256 _amount) public nonReentrant {

        require(_tokenAddress == springTokenAddress || _tokenAddress == summerTokenAddress
                || _tokenAddress == autumnTokenAddress || _tokenAddress == winterTokenAddress,
                "Only Seasonal Tokens can be donated");

        require(msg.sender == from, "Tokens must be donated by the address that owns them.");

        allocateIncomingTokensToTradingPairs(_tokenAddress, _amount);

        emit Donate(from, _tokenAddress, _amount);

        IERC20(_tokenAddress).safeTransferFrom(from, address(this), _amount);
    }

    function onERC721Received(address _operator, address _from, uint256 _liquidityTokenId, bytes calldata _data)
                             external override returns(bytes4) {

        require(msg.sender == address(nonfungiblePositionManager), 
                "Only Uniswap v3 liquidity tokens can be deposited");

        LiquidityToken memory liquidityToken = getLiquidityToken(_liquidityTokenId);
        
        liquidityToken.owner = _from;
        liquidityToken.depositTime = block.timestamp;

        tokenOfOwnerByIndex[_from].add(_liquidityTokenId);

        liquidityToken.initialCumulativeSpringTokensFarmed
            = cumulativeTokensFarmedPerUnitLiquidity[liquidityToken.seasonalToken][springTokenAddress];

        liquidityToken.initialCumulativeSummerTokensFarmed
            = cumulativeTokensFarmedPerUnitLiquidity[liquidityToken.seasonalToken][summerTokenAddress];

        liquidityToken.initialCumulativeAutumnTokensFarmed
            = cumulativeTokensFarmedPerUnitLiquidity[liquidityToken.seasonalToken][autumnTokenAddress];

        liquidityToken.initialCumulativeWinterTokensFarmed
            = cumulativeTokensFarmedPerUnitLiquidity[liquidityToken.seasonalToken][winterTokenAddress];

        liquidityTokens[_liquidityTokenId] = liquidityToken;
        totalLiquidity[liquidityToken.seasonalToken] += liquidityToken.liquidity;

        emit Deposit(_from, _liquidityTokenId);

        _data; _operator; // suppress unused variable compiler warnings
        return IERC721Receiver.onERC721Received.selector;
    }

    function getLiquidityToken(uint256 _tokenId) internal view returns(LiquidityToken memory) {

        LiquidityToken memory liquidityToken;
        address token0;
        address token1;
        int24 tickLower;
        int24 tickUpper;
        uint256 liquidity;
        uint24 fee;
        
        (token0, token1, fee, tickLower, tickUpper, liquidity) = getPositionDataForLiquidityToken(_tokenId);
        liquidityToken.liquidity = liquidity;
        
        if (token0 == wethAddress)
            liquidityToken.seasonalToken = token1;
        else if (token1 == wethAddress)
            liquidityToken.seasonalToken = token0;

        require(liquidityToken.seasonalToken == springTokenAddress ||
                liquidityToken.seasonalToken == summerTokenAddress ||
                liquidityToken.seasonalToken == autumnTokenAddress ||
                liquidityToken.seasonalToken == winterTokenAddress,
                "Invalid trading pair");

        require(tickLower == REQUIRED_TICK_LOWER && tickUpper == REQUIRED_TICK_UPPER,
                "Liquidity must cover full range of prices");

        require(fee == 100, "Fee tier must be 0.01%");

        return liquidityToken;
    }

    function getPositionDataForLiquidityToken(uint256 _tokenId)
                                             internal view returns (address, address, uint24, int24, int24, uint256){
        address token0;
        address token1;
        int24 tickLower;
        int24 tickUpper;
        uint256 liquidity;
        uint24 fee;

        (,, token0, token1, fee, tickLower, tickUpper, liquidity,,,,) 
            = nonfungiblePositionManager.positions(_tokenId);

        return (token0, token1, fee, tickLower, tickUpper, liquidity);
    }

    function setCumulativeSpringTokensFarmedToCurrentValue(uint256 _liquidityTokenId, address _seasonalToken) internal {
        liquidityTokens[_liquidityTokenId].initialCumulativeSpringTokensFarmed
            = cumulativeTokensFarmedPerUnitLiquidity[_seasonalToken][springTokenAddress];
    }

    function setCumulativeSummerTokensFarmedToCurrentValue(uint256 _liquidityTokenId, address _seasonalToken) internal {
        liquidityTokens[_liquidityTokenId].initialCumulativeSummerTokensFarmed
            = cumulativeTokensFarmedPerUnitLiquidity[_seasonalToken][summerTokenAddress];
    }

    function setCumulativeAutumnTokensFarmedToCurrentValue(uint256 _liquidityTokenId, address _seasonalToken) internal {
        liquidityTokens[_liquidityTokenId].initialCumulativeAutumnTokensFarmed
            = cumulativeTokensFarmedPerUnitLiquidity[_seasonalToken][autumnTokenAddress];
    }

    function setCumulativeWinterTokensFarmedToCurrentValue(uint256 _liquidityTokenId, address _seasonalToken) internal {
        liquidityTokens[_liquidityTokenId].initialCumulativeWinterTokensFarmed
            = cumulativeTokensFarmedPerUnitLiquidity[_seasonalToken][winterTokenAddress];
    }

    function getPayoutSize(uint256 _liquidityTokenId, address _farmedSeasonalToken,
                           address _tradingPairSeasonalToken) internal view returns (uint256) {

        uint256 initialCumulativeTokensFarmed;

        if (_farmedSeasonalToken == springTokenAddress)
            initialCumulativeTokensFarmed = liquidityTokens[_liquidityTokenId].initialCumulativeSpringTokensFarmed;
        else if (_farmedSeasonalToken == summerTokenAddress)
            initialCumulativeTokensFarmed = liquidityTokens[_liquidityTokenId].initialCumulativeSummerTokensFarmed;
        else if (_farmedSeasonalToken == autumnTokenAddress)
            initialCumulativeTokensFarmed = liquidityTokens[_liquidityTokenId].initialCumulativeAutumnTokensFarmed;
        else
            initialCumulativeTokensFarmed = liquidityTokens[_liquidityTokenId].initialCumulativeWinterTokensFarmed;

        uint256 tokensFarmedPerUnitLiquiditySinceDeposit 
            = cumulativeTokensFarmedPerUnitLiquidity[_tradingPairSeasonalToken][_farmedSeasonalToken]
              - initialCumulativeTokensFarmed;

        return (tokensFarmedPerUnitLiquiditySinceDeposit 
                * liquidityTokens[_liquidityTokenId].liquidity) / (2 ** 128);
    }

    function getPayoutSizes(uint256 _liquidityTokenId) external view returns (uint256, uint256, uint256, uint256) {

        address tradingPairSeasonalToken = liquidityTokens[_liquidityTokenId].seasonalToken;

        uint256 springPayout = getPayoutSize(_liquidityTokenId, springTokenAddress, tradingPairSeasonalToken);
        uint256 summerPayout = getPayoutSize(_liquidityTokenId, summerTokenAddress, tradingPairSeasonalToken);
        uint256 autumnPayout = getPayoutSize(_liquidityTokenId, autumnTokenAddress, tradingPairSeasonalToken);
        uint256 winterPayout = getPayoutSize(_liquidityTokenId, winterTokenAddress, tradingPairSeasonalToken);

        return (springPayout, summerPayout, autumnPayout, winterPayout);
    }

    function harvestSpring(uint256 _liquidityTokenId, address _tradingPairSeasonalToken) internal returns(uint256) {

        uint256 amount = getPayoutSize(_liquidityTokenId, springTokenAddress, _tradingPairSeasonalToken);
        setCumulativeSpringTokensFarmedToCurrentValue(_liquidityTokenId, _tradingPairSeasonalToken);
        return amount;
    }

    function harvestSummer(uint256 _liquidityTokenId, address _tradingPairSeasonalToken) internal returns(uint256) {

        uint256 amount = getPayoutSize(_liquidityTokenId, summerTokenAddress, _tradingPairSeasonalToken);
        setCumulativeSummerTokensFarmedToCurrentValue(_liquidityTokenId, _tradingPairSeasonalToken);
        return amount;
    }

    function harvestAutumn(uint256 _liquidityTokenId, address _tradingPairSeasonalToken) internal returns(uint256) {

        uint256 amount = getPayoutSize(_liquidityTokenId, autumnTokenAddress, _tradingPairSeasonalToken);
        setCumulativeAutumnTokensFarmedToCurrentValue(_liquidityTokenId, _tradingPairSeasonalToken);
        return amount;
    }

    function harvestWinter(uint256 _liquidityTokenId, address _tradingPairSeasonalToken) internal returns(uint256) {

        uint256 amount = getPayoutSize(_liquidityTokenId, winterTokenAddress, _tradingPairSeasonalToken);
        setCumulativeWinterTokensFarmedToCurrentValue(_liquidityTokenId, _tradingPairSeasonalToken);
        return amount;
    }

    function harvestAll(uint256 _liquidityTokenId, address _tradingPairSeasonalToken)
            internal returns (uint256, uint256, uint256, uint256) {

        uint256 springAmount = harvestSpring(_liquidityTokenId, _tradingPairSeasonalToken);
        uint256 summerAmount = harvestSummer(_liquidityTokenId, _tradingPairSeasonalToken);
        uint256 autumnAmount = harvestAutumn(_liquidityTokenId, _tradingPairSeasonalToken);
        uint256 winterAmount = harvestWinter(_liquidityTokenId, _tradingPairSeasonalToken);

        return (springAmount, summerAmount, autumnAmount, winterAmount);
    }

    function sendHarvestedTokensToOwner(address _tokenOwner, uint256 _springAmount, uint256 _summerAmount,
                                        uint256 _autumnAmount, uint256 _winterAmount) internal {

        if (_springAmount > 0)
            IERC20(springTokenAddress).transfer(_tokenOwner, _springAmount);
        if (_summerAmount > 0)
            IERC20(summerTokenAddress).transfer(_tokenOwner, _summerAmount);
        if (_autumnAmount > 0)
            IERC20(autumnTokenAddress).transfer(_tokenOwner, _autumnAmount);
        if (_winterAmount > 0)
            IERC20(winterTokenAddress).transfer(_tokenOwner, _winterAmount);
    }

    function harvest(uint256 _liquidityTokenId) external {
        
        LiquidityToken storage liquidityToken = liquidityTokens[_liquidityTokenId];
        require(msg.sender == liquidityToken.owner, "Only owner can harvest");
        
        (uint256 springAmount, 
         uint256 summerAmount,
         uint256 autumnAmount,
         uint256 winterAmount) = harvestAll(_liquidityTokenId, liquidityToken.seasonalToken);

        emit Harvest(msg.sender, _liquidityTokenId, springAmount, summerAmount, autumnAmount, winterAmount);
        
        sendHarvestedTokensToOwner(msg.sender, springAmount, summerAmount, autumnAmount, winterAmount);
    }

    function canWithdraw(uint256 _liquidityTokenId) public view returns (bool) {

        uint256 depositTime = liquidityTokens[_liquidityTokenId].depositTime;
        uint256 timeSinceDepositTime = block.timestamp - depositTime;
        uint256 daysSinceDepositTime = timeSinceDepositTime / (24 * 60 * 60);

        return (daysSinceDepositTime) % (WITHDRAWAL_UNAVAILABLE_DAYS + WITHDRAWAL_AVAILABLE_DAYS) 
                    >= WITHDRAWAL_UNAVAILABLE_DAYS;
    }

    function nextWithdrawalTime(uint256 _liquidityTokenId) external view returns (uint256) {
        
        uint256 depositTime = liquidityTokens[_liquidityTokenId].depositTime;
        uint256 timeSinceDepositTime = block.timestamp - depositTime;
        uint256 withdrawalUnavailableTime = WITHDRAWAL_UNAVAILABLE_DAYS * 24 * 60 * 60;
        uint256 withdrawalAvailableTime = WITHDRAWAL_AVAILABLE_DAYS * 24 * 60 * 60;

        if (timeSinceDepositTime < withdrawalUnavailableTime)
            return depositTime + withdrawalUnavailableTime;

        uint256 numberOfWithdrawalCyclesUntilNextWithdrawalTime 
                    = 1 + (timeSinceDepositTime - withdrawalUnavailableTime) 
                          / (withdrawalUnavailableTime + withdrawalAvailableTime);

        return depositTime + withdrawalUnavailableTime 
                           + numberOfWithdrawalCyclesUntilNextWithdrawalTime
                             * (withdrawalUnavailableTime + withdrawalAvailableTime);
    }

    function withdraw(uint256 _liquidityTokenId) external {

        require(canWithdraw(_liquidityTokenId), "This token cannot be withdrawn at this time");

        LiquidityToken memory liquidityToken = liquidityTokens[_liquidityTokenId];

        require(msg.sender == liquidityToken.owner, "Only owner can withdraw");

        (uint256 springAmount, 
         uint256 summerAmount,
         uint256 autumnAmount,
         uint256 winterAmount) = harvestAll(_liquidityTokenId, liquidityToken.seasonalToken);

        totalLiquidity[liquidityToken.seasonalToken] -= liquidityToken.liquidity;
        removeTokenFromListOfOwnedTokens(msg.sender, _liquidityTokenId);
        
        emit Harvest(msg.sender, _liquidityTokenId, springAmount, summerAmount, autumnAmount, winterAmount);
        emit Withdraw(msg.sender, _liquidityTokenId);

        sendHarvestedTokensToOwner(msg.sender, springAmount, summerAmount, autumnAmount, winterAmount);
        nonfungiblePositionManager.safeTransferFrom(address(this), liquidityToken.owner, _liquidityTokenId);
    }

    function removeTokenFromListOfOwnedTokens(address _owner, uint256 _liquidityTokenId) internal {
        tokenOfOwnerByIndex[_owner].remove(_liquidityTokenId);
        delete liquidityTokens[_liquidityTokenId];
    }

}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.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");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

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

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface INonfungiblePositionManager {
    function positions(uint256 tokenId)
    external
    view
    returns (
        uint96 nonce,
        address operator,
        address token0,
        address token1,
        uint24 fee,
        int24 tickLower,
        int24 tickUpper,
        uint128 liquidity,
        uint256 feeGrowthInside0LastX128,
        uint256 feeGrowthInside1LastX128,
        uint128 tokensOwed0,
        uint128 tokensOwed1
    );

    function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

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

pragma solidity ^0.8.0;

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

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

    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'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract INonfungiblePositionManager","name":"_nonfungiblePositionManager","type":"address"},{"internalType":"address","name":"_springTokenAddress","type":"address"},{"internalType":"address","name":"_summerTokenAddress","type":"address"},{"internalType":"address","name":"_autumnTokenAddress","type":"address"},{"internalType":"address","name":"_winterTokenAddress","type":"address"},{"internalType":"address","name":"_wethAddress","type":"address"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"liquidityTokenId","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"seasonalTokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Donate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenOwner","type":"address"},{"indexed":false,"internalType":"uint256","name":"liquidityTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"springAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"summerAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"autumnAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"winterAmount","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenOwner","type":"address"},{"indexed":false,"internalType":"uint256","name":"liquidityTokenId","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"REALLOCATION_INTERVAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REQUIRED_TICK_LOWER","outputs":[{"internalType":"int24","name":"","type":"int24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REQUIRED_TICK_UPPER","outputs":[{"internalType":"int24","name":"","type":"int24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WITHDRAWAL_AVAILABLE_DAYS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WITHDRAWAL_UNAVAILABLE_DAYS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autumnAllocationSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autumnTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_liquidityProvider","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_liquidityTokenId","type":"uint256"}],"name":"canWithdraw","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"cumulativeTokensFarmedPerUnitLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_totalSpringLiquidity","type":"uint256"},{"internalType":"uint256","name":"_totalSummerLiquidity","type":"uint256"},{"internalType":"uint256","name":"_totalAutumnLiquidity","type":"uint256"},{"internalType":"uint256","name":"_totalWinterLiquidity","type":"uint256"}],"name":"getEffectiveTotalAllocationSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_liquidityTokenId","type":"uint256"}],"name":"getPayoutSizes","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"getValueFromTokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_liquidityTokenId","type":"uint256"}],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"liquidityTokens","outputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"seasonalToken","type":"address"},{"internalType":"uint256","name":"depositTime","type":"uint256"},{"internalType":"uint256","name":"initialCumulativeSpringTokensFarmed","type":"uint256"},{"internalType":"uint256","name":"initialCumulativeSummerTokensFarmed","type":"uint256"},{"internalType":"uint256","name":"initialCumulativeAutumnTokensFarmed","type":"uint256"},{"internalType":"uint256","name":"initialCumulativeWinterTokensFarmed","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_liquidityTokenId","type":"uint256"}],"name":"nextWithdrawalTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nonfungiblePositionManager","outputs":[{"internalType":"contract INonfungiblePositionManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberOfReAllocations","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"},{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_liquidityTokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"receiveSeasonalTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"springAllocationSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"springTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"summerAllocationSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"summerTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"totalLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wethAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"winterAllocationSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"winterTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_liquidityTokenId","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000c36442b4a4522e871399cd717abdd847ab11fe8800000000000000000000000070d59baa5ab360b2723dd561415bdbcd4435e1c4000000000000000000000000dd28ec6b06983d01d37dbd9ab581d8d884d95264000000000000000000000000fba4d30e964e40775c95b58acf6b5a621b929c0a00000000000000000000000051540d15957bdc0fdb87d32616c8d658d59f77c60000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf12700000000000000000000000000000000000000000000000000000000061d4df80

-----Decoded View---------------
Arg [0] : _nonfungiblePositionManager (address): 0xC36442b4a4522E871399CD717aBDD847Ab11FE88
Arg [1] : _springTokenAddress (address): 0x70d59baA5ab360b2723dD561415bdBcD4435E1C4
Arg [2] : _summerTokenAddress (address): 0xdd28ec6b06983d01D37DbD9Ab581d8d884d95264
Arg [3] : _autumnTokenAddress (address): 0xfbA4d30e964E40775C95B58AcF6b5A621b929c0a
Arg [4] : _winterTokenAddress (address): 0x51540D15957bDC0fdb87d32616c8d658D59f77C6
Arg [5] : _wethAddress (address): 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270
Arg [6] : _startTime (uint256): 1641340800

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 000000000000000000000000c36442b4a4522e871399cd717abdd847ab11fe88
Arg [1] : 00000000000000000000000070d59baa5ab360b2723dd561415bdbcd4435e1c4
Arg [2] : 000000000000000000000000dd28ec6b06983d01d37dbd9ab581d8d884d95264
Arg [3] : 000000000000000000000000fba4d30e964e40775c95b58acf6b5a621b929c0a
Arg [4] : 00000000000000000000000051540d15957bdc0fdb87d32616c8d658d59f77c6
Arg [5] : 0000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf1270
Arg [6] : 0000000000000000000000000000000000000000000000000000000061d4df80

1397:19641:8:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4399:118;;;:::i;:::-;;;13718:25:9;;;13706:2;13691:18;4399:118:8;;;;;;;;14232:730;;;;;;:::i;:::-;;:::i;:::-;;;;13985:25:9;;;14041:2;14026:18;;14019:34;;;;14069:18;;;14062:34;14127:2;14112:18;;14105:34;13972:3;13957:19;14232:730:8;13939:206:9;18761:993:8;;;;;;:::i;:::-;;:::i;8515:1545::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;;7348:33:9;;;7330:52;;7318:2;7303:18;8515:1545:8;7285:103:9;2204:43:8;;;;;;;;-1:-1:-1;;;;;5551:32:9;;;5533:51;;5521:2;5506:18;2204:43:8;5488:102:9;4523:118:8;;;:::i;4740:165::-;;;;;;:::i;:::-;;:::i;1810:53::-;;1862:1;1810:53;;2155:43;;;;;2057;;;;;19760:1054;;;;;;:::i;:::-;;:::i;:::-;;1690:51;;-1:-1:-1;;1690:51:8;;;;;7808:1:9;7797:21;;;;7779:40;;7767:2;7752:18;1690:51:8;7734:91:9;7857:652:8;;;;;;:::i;:::-;;:::i;2253:36::-;;;;;2106:43;;;;;3672:151;;;;;;:::i;:::-;;:::i;2374:34::-;;;;;2415:93;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;4911:776;;;;;;:::i;:::-;;:::i;4275:118::-;;;:::i;2296:71::-;;;;;1748:56;;1802:2;1748:56;;1870:49;;;;;;:::i;:::-;;;;;;;;;;;;;;4647:87;4726:1;4647:87;;1551:76;;1599:28;1551:76;;17636:652;;;;;;:::i;:::-;;:::i;1634:50::-;;1678:6;1634:50;;3829:274;;;:::i;18294:461::-;;;;;;:::i;:::-;;:::i;:::-;;;7159:14:9;;7152:22;7134:41;;7122:2;7107:18;18294:461:8;7089:92:9;1993:57:8;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1993:57:8;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;6374:15:9;;;6356:34;;6426:15;;;;6421:2;6406:18;;6399:43;6458:18;;;6451:34;;;;6516:2;6501:18;;6494:34;;;;6559:3;6544:19;;6537:35;6336:3;6588:19;;6581:35;6647:3;6632:19;;6625:35;6691:3;6676:19;;6669:35;6305:3;6290:19;1993:57:8;6272:438:9;4399:118:8;4452:7;4487:23;4508:1;4487:20;:23::i;:::-;4482:28;;:1;:28;:::i;:::-;4478:32;;:1;:32;:::i;:::-;4471:39;;4399:118;:::o;14232:730::-;14306:7;14388:34;;;:15;:34;;;;;:48;;;14306:7;;;;;;-1:-1:-1;;;;;14388:48:8;14306:7;14470:78;14404:17;14503:18;14388:48;14470:13;:78::i;:::-;14447:101;;14558:20;14581:78;14595:17;14614:18;14634:24;14581:13;:78::i;:::-;14558:101;;14669:20;14692:78;14706:17;14725:18;14745:24;14692:13;:78::i;:::-;14669:101;;14780:20;14803:78;14817:17;14836:18;14856:24;14803:13;:78::i;:::-;14900:12;;14914;;-1:-1:-1;14928:12:8;;-1:-1:-1;14900:12:8;;-1:-1:-1;14232:730:8;-1:-1:-1;;;;14232:730:8:o;18761:993::-;18839:7;18889:34;;;:15;:34;;;;;:46;;;18839:7;18976:29;18889:46;18976:15;:29;:::i;:::-;18945:60;-1:-1:-1;19015:33:8;19051:32;1802:2;19081;19051:32;:::i;:::-;:37;;19086:2;19051:37;:::i;:::-;:42;;19091:2;19051:42;:::i;:::-;19015:78;-1:-1:-1;19103:31:8;19137:30;1862:1;19165:2;19137:30;:::i;:::-;:35;;19170:2;19137:35;:::i;:::-;:40;;19175:2;19137:40;:::i;:::-;19103:74;;19215:25;19192:20;:48;19188:112;;;19261:39;19275:25;19261:11;:39;:::i;:::-;19254:46;18761:993;-1:-1:-1;;;;;;18761:993:8:o;19188:112::-;19311:55;19475:51;19503:23;19475:25;:51;:::i;:::-;19395:48;19418:25;19395:20;:48;:::i;:::-;19394:133;;;;:::i;:::-;19390:137;;:1;:137;:::i;:::-;19311:216;-1:-1:-1;19695:51:8;19723:23;19695:25;:51;:::i;:::-;19615:132;;:47;:132;:::i;:::-;19545:39;19559:25;19545:11;:39;:::i;:::-;:202;;;;:::i;:::-;19538:209;18761:993;-1:-1:-1;;;;;;;18761:993:8:o;8515:1545::-;8679:6;8706:10;-1:-1:-1;;;;;8728:26:8;8706:49;;8698:128;;;;-1:-1:-1;;;8698:128:8;;11473:2:9;8698:128:8;;;11455:21:9;11512:2;11492:18;;;11485:30;11551:34;11531:18;;;11524:62;-1:-1:-1;;;11602:18:9;;;11595:47;11659:19;;8698:128:8;;;;;;;;;8837:36;8876;8894:17;8876;:36::i;:::-;-1:-1:-1;;;;;8931:28:8;;;;;8998:15;8969:26;;;;:44;;;;8931:20;9024:26;;;:19;:26;;;;8837:75;;-1:-1:-1;9024:49:8;;9055:17;9024:30;:49::i;:::-;-1:-1:-1;9188:28:8;;;;;;-1:-1:-1;;;;;9149:68:8;;;;;;;:38;:68;;;;;;;9218:18;9149:88;;;;;;;;;;9084:50;;;:153;;;9352:28;;9313:68;;;;;;;;;;9382:18;9313:88;;;;;;;;;;9248:50;;;:153;;;9516:28;;9477:68;;;;;;;;;;9546:18;9477:88;;;;;;;;;;9412:50;;;:153;;;9680:28;;9641:68;;;;;;;;;;9710:18;9641:88;;;;;;;;;;9576:50;;;:153;;;9740:34;;;:15;:34;;;;;;:51;;;;;;;-1:-1:-1;;;;;;9740:51:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9801:44;;;;;;;;;:72;;9740:51;;9801:44;;:72;;9740:51;;9801:72;:::i;:::-;;;;-1:-1:-1;;9889:33:8;;13718:25:9;;;-1:-1:-1;;;;;9889:33:8;;;;;13706:2:9;13691:18;9889:33:8;;;;;;;-1:-1:-1;;;;10012:41:8;8515:1545;-1:-1:-1;;;;;;8515:1545:8:o;4523:118::-;4576:7;4611:23;4632:1;4611:20;:23::i;:::-;4606:28;;:1;:28;:::i;:::-;4602:32;;:1;:32;:::i;4740:165::-;-1:-1:-1;;;;;4860:27:8;;4834:7;4860:27;;;:19;:27;;;;;:38;;4891:6;4860:30;:38::i;:::-;4853:45;;4740:165;;;;;:::o;19760:1054::-;19833:30;19845:17;19833:11;:30::i;:::-;19825:86;;;;-1:-1:-1;;;19825:86:8;;12651:2:9;19825:86:8;;;12633:21:9;12690:2;12670:18;;;12663:30;12729:34;12709:18;;;12702:62;-1:-1:-1;;;12780:18:9;;;12773:41;12831:19;;19825:86:8;12623:233:9;19825:86:8;19922:36;19961:34;;;:15;:34;;;;;;;;;19922:73;;;;;;;;;-1:-1:-1;;;;;19922:73:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20014:10;:34;20006:70;;;;-1:-1:-1;;;20006:70:8;;8827:2:9;20006:70:8;;;8809:21:9;8866:2;8846:18;;;8839:30;8905:25;8885:18;;;8878:53;8948:18;;20006:70:8;8799:173:9;20006:70:8;20088:20;20120;20151;20182;20206:59;20217:17;20236:14;:28;;;20206:10;:59::i;:::-;20087:178;;;;;;;;20324:14;:24;;;20276:14;:44;20291:14;:28;;;-1:-1:-1;;;;;20276:44:8;-1:-1:-1;;;;;20276:44:8;;;;;;;;;;;;;:72;;;;;;;:::i;:::-;;;;-1:-1:-1;20358:63:8;;-1:-1:-1;20391:10:8;20403:17;20358:32;:63::i;:::-;20445:94;;;14409:25:9;;;14465:2;14450:18;;14443:34;;;14493:18;;;14486:34;;;14551:2;14536:18;;14529:34;;;14594:3;14579:19;;14572:35;;;20453:10:8;;20445:94;;14396:3:9;14381:19;20445:94:8;;;;;;;20554:39;;13718:25:9;;;20563:10:8;;20554:39;;13706:2:9;13691:18;20554:39:8;;;;;;;20604:94;20631:10;20643:12;20657;20671;20685;20604:26;:94::i;:::-;20767:20;;20708:99;;-1:-1:-1;;;20708:99:8;;20760:4;20708:99;;;5835:34:9;-1:-1:-1;;;;;5905:15:9;;;5885:18;;;5878:43;5937:18;;;5930:34;;;20708:26:8;:43;;;;;;5770:18:9;;20708:99:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19814:1000;;;;;19760:1054;:::o;7857:652::-;2246:21:6;:19;:21::i;:::-;7998:18:8::1;-1:-1:-1::0;;;;;7981:35:8::1;:13;-1:-1:-1::0;;;;;7981:35:8::1;;:74;;;;8037:18;-1:-1:-1::0;;;;;8020:35:8::1;:13;-1:-1:-1::0;;;;;8020:35:8::1;;7981:74;:129;;;;8092:18;-1:-1:-1::0;;;;;8075:35:8::1;:13;-1:-1:-1::0;;;;;8075:35:8::1;;7981:129;:168;;;;8131:18;-1:-1:-1::0;;;;;8114:35:8::1;:13;-1:-1:-1::0;;;;;8114:35:8::1;;7981:168;7973:232;;;::::0;-1:-1:-1;;;7973:232:8;;10011:2:9;7973:232:8::1;::::0;::::1;9993:21:9::0;10050:2;10030:18;;;10023:30;10089:34;10069:18;;;10062:62;-1:-1:-1;;;10140:18:9;;;10133:33;10183:19;;7973:232:8::1;9983:225:9::0;7973:232:8::1;8224:10;-1:-1:-1::0;;;;;8224:18:8;::::1;;8216:84;;;::::0;-1:-1:-1;;;8216:84:8;;9589:2:9;8216:84:8::1;::::0;::::1;9571:21:9::0;9628:2;9608:18;;;9601:30;9667:34;9647:18;;;9640:62;-1:-1:-1;;;9718:18:9;;;9711:51;9779:19;;8216:84:8::1;9561:243:9::0;8216:84:8::1;8311:60;8348:13;8363:7;8311:36;:60::i;:::-;8387:36;::::0;;-1:-1:-1;;;;;6907:32:9;;;6889:51;;6971:2;6956:18;;6949:34;;;8387:36:8;::::1;::::0;::::1;::::0;6862:18:9;8387:36:8::1;;;;;;;8434:68;-1:-1:-1::0;;;;;8434:38:8;::::1;8473:4:::0;8487::::1;8494:7:::0;8434:38:::1;:68::i;:::-;2288:20:6::0;1701:1;2794:7;:22;2614:209;2288:20;7857:652:8;;;:::o;3672:151::-;-1:-1:-1;;;;;3768:39:8;;3742:7;3768:39;;;:19;:39;;;;;:48;;:46;:48::i;4911:776::-;5232:7;;5291:25;;5287:83;;5348:22;:20;:22::i;:::-;5330:40;;;;:::i;:::-;;;5287:83;5384:25;;5380:83;;5441:22;:20;:22::i;:::-;5423:40;;;;:::i;:::-;;;5380:83;5477:25;;5473:83;;5534:22;:20;:22::i;:::-;5516:40;;;;:::i;:::-;;;5473:83;5570:25;;5566:83;;5609:40;4726:1;5609:40;;:::i;:::-;;;5566:83;5666:14;-1:-1:-1;4911:776:8;;;;;;;:::o;4275:118::-;4328:7;4363:23;4384:1;4363:20;:23::i;:::-;4358:28;;:1;:28;:::i;:::-;4354:32;;:1;:32;:::i;17636:652::-;17708:37;17748:34;;;:15;:34;;;;;17814:20;;-1:-1:-1;;;;;17814:20:8;17800:10;:34;17792:69;;;;-1:-1:-1;;;17792:69:8;;13423:2:9;17792:69:8;;;13405:21:9;13462:2;13442:18;;;13435:30;-1:-1:-1;;;13481:18:9;;;13474:52;13543:18;;17792:69:8;13395:172:9;17792:69:8;18029:28;;;;17881:20;;;;;;;;17999:59;;18010:17;;-1:-1:-1;;;;;18029:28:8;17999:10;:59::i;:::-;18074:94;;;14409:25:9;;;14465:2;14450:18;;14443:34;;;14493:18;;;14486:34;;;14551:2;14536:18;;14529:34;;;14594:3;14579:19;;14572:35;;;17880:178:8;;-1:-1:-1;17880:178:8;;-1:-1:-1;17880:178:8;-1:-1:-1;17880:178:8;-1:-1:-1;18082:10:8;;18074:94;;14396:3:9;14381:19;18074:94:8;;;;;;;18187;18214:10;18226:12;18240;18254;18268;18187:26;:94::i;:::-;17689:599;;;;;17636:652;:::o;3829:274::-;3883:7;3924:33;1599:28;3924:9;:33;:::i;:::-;3906:15;:51;3902:77;;;-1:-1:-1;3978:1:8;;3829:274::o;3902:77::-;3989:22;4014:27;4032:9;4014:15;:27;:::i;:::-;3989:52;-1:-1:-1;4058:38:8;1599:28;3989:52;4058:38;:::i;:::-;4051:45;;;3829:274;:::o;18294:461::-;18363:4;18402:34;;;:15;:34;;;;;:46;;;18363:4;18489:29;18402:46;18489:15;:29;:::i;:::-;18458:60;-1:-1:-1;18528:28:8;18559:37;18583:12;18458:60;18559:37;:::i;:::-;18528:68;-1:-1:-1;1802:2:8;18640:55;1862:1;1802:2;18640:55;:::i;:::-;18614:82;;18615:20;18614:82;:::i;:::-;:134;;;18294:461;-1:-1:-1;;;;;18294:461:8:o;4109:160::-;4184:7;4241:12;4237:1;4211:23;:21;:23::i;:::-;:27;;;;:::i;:::-;:42;4210:52;;4261:1;4210:52;;;4257:1;4210:52;4203:59;;;4109:160;-1:-1:-1;;4109:160:8:o;12996:1230::-;13161:7;13181:37;13257:18;-1:-1:-1;;;;;13233:42:8;:20;-1:-1:-1;;;;;13233:42:8;;13229:645;;;-1:-1:-1;13321:34:8;;;;:15;:34;;;;;;;;:70;;13229:645;;;13434:18;-1:-1:-1;;;;;13410:42:8;:20;-1:-1:-1;;;;;13410:42:8;;13406:468;;;-1:-1:-1;13498:34:8;;;;:15;:34;;;;;:70;;;13406:468;;;13611:18;-1:-1:-1;;;;;13587:42:8;:20;-1:-1:-1;;;;;13587:42:8;;13583:291;;;-1:-1:-1;13675:34:8;;;;:15;:34;;;;;:70;;;13583:291;;;-1:-1:-1;13804:34:8;;;;:15;:34;;;;;:70;;;13583:291;-1:-1:-1;;;;;13949:65:8;;;13885:48;13949:65;;;:38;:65;;;;;;;;:87;;;;;;;;;;;;:133;;14053:29;;13949:133;:::i;:::-;14161:34;;;;:15;:34;;;;;:44;;;13885:197;;-1:-1:-1;;;;14210:8:8;14101:104;;13885:197;14101:104;:::i;:::-;14100:119;;;;:::i;10066:1196::-;10133:21;;:::i;:::-;10167:36;;:::i;:::-;10213:14;10237;10261:15;10286;10311:17;10338:10;10424:42;10457:8;10424:32;:42::i;:::-;10476:24;;;:36;;;10367:99;;-1:-1:-1;10367:99:8;;-1:-1:-1;10367:99:8;-1:-1:-1;10367:99:8;;-1:-1:-1;10476:36:8;;-1:-1:-1;10367:99:8;-1:-1:-1;10545:11:8;-1:-1:-1;;;;;10535:21:8;;;;;;;10531:167;;;-1:-1:-1;;;;;10570:37:8;;:28;;;:37;10531:167;;;10636:11;-1:-1:-1;;;;;10626:21:8;:6;-1:-1:-1;;;;;10626:21:8;;10622:76;;;-1:-1:-1;;;;;10661:37:8;;:28;;;:37;10622:76;10749:18;-1:-1:-1;;;;;10717:50:8;:14;:28;;;-1:-1:-1;;;;;10717:50:8;;:120;;;;10819:18;-1:-1:-1;;;;;10787:50:8;:14;:28;;;-1:-1:-1;;;;;10787:50:8;;10717:120;:190;;;;10889:18;-1:-1:-1;;;;;10857:50:8;:14;:28;;;-1:-1:-1;;;;;10857:50:8;;10717:190;:260;;;;10959:18;-1:-1:-1;;;;;10927:50:8;:14;:28;;;-1:-1:-1;;;;;10927:50:8;;10717:260;10709:309;;;;-1:-1:-1;;;10709:309:8;;11891:2:9;10709:309:8;;;11873:21:9;11930:2;11910:18;;;11903:30;-1:-1:-1;;;11949:18:9;;;11942:50;12009:18;;10709:309:8;11863:170:9;10709:309:8;11037:32;;;;-1:-1:-1;;11037:32:8;:68;;;;-1:-1:-1;11073:32:8;;;;1678:6;11073:32;11037:68;11029:138;;;;-1:-1:-1;;;11029:138:8;;9179:2:9;11029:138:8;;;9161:21:9;9218:2;9198:18;;;9191:30;9257:34;9237:18;;;9230:62;-1:-1:-1;;;9308:18:9;;;9301:39;9357:19;;11029:138:8;9151:231:9;11029:138:8;11186:3;:10;;11193:3;11186:10;11178:45;;;;-1:-1:-1;;;11178:45:8;;10415:2:9;11178:45:8;;;10397:21:9;10454:2;10434:18;;;10427:30;-1:-1:-1;;;10473:18:9;;;10466:52;10535:18;;11178:45:8;10387:172:9;11178:45:8;-1:-1:-1;11241:14:8;;10066:1196;-1:-1:-1;;;;;;;10066:1196:8:o;10785:129:1:-;10852:4;10875:32;10880:3;10900:5;10875:4;:32::i;11977:135::-;12048:7;12082:22;12086:3;12098:5;12082:3;:22::i;16388:598:8:-;16500:7;16509;16518;16527;16547:20;16570:59;16584:17;16603:25;16570:13;:59::i;:::-;16547:82;;16639:20;16662:59;16676:17;16695:25;16662:13;:59::i;:::-;16639:82;;16731:20;16754:59;16768:17;16787:25;16754:13;:59::i;:::-;16731:82;;16823:20;16846:59;16860:17;16879:25;16846:13;:59::i;20820:215::-;-1:-1:-1;;;;;20924:27:8;;;;;;:19;:27;;;;;:53;;20959:17;20924:34;:53::i;:::-;-1:-1:-1;20994:34:8;;;;:15;:34;;;;;;;20987:41;;-1:-1:-1;;;;;;20987:41:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20820:215:8:o;16992:638::-;17205:17;;17201:98;;17236:63;;-1:-1:-1;;;17236:63:8;;-1:-1:-1;;;;;6907:32:9;;;17236:63:8;;;6889:51:9;6956:18;;;6949:34;;;17243:18:8;17236:35;;;;6862:18:9;;17236:63:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;17201:98;17313:17;;17309:98;;17344:63;;-1:-1:-1;;;17344:63:8;;-1:-1:-1;;;;;6907:32:9;;;17344:63:8;;;6889:51:9;6956:18;;;6949:34;;;17351:18:8;17344:35;;;;6862:18:9;;17344:63:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;17309:98;17421:17;;17417:98;;17452:63;;-1:-1:-1;;;17452:63:8;;-1:-1:-1;;;;;6907:32:9;;;17452:63:8;;;6889:51:9;6956:18;;;6949:34;;;17459:18:8;17452:35;;;;6862:18:9;;17452:63:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;17417:98;17529:17;;17525:98;;17560:63;;-1:-1:-1;;;17560:63:8;;-1:-1:-1;;;;;6907:32:9;;;17560:63:8;;;6889:51:9;6956:18;;;6949:34;;;17567:18:8;17560:35;;;;6862:18:9;;17560:63:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;17525:98::-;16992:638;;;;;:::o;2321:287:6:-;1744:1;2453:7;;:19;;2445:63;;;;-1:-1:-1;;;2445:63:6;;13063:2:9;2445:63:6;;;13045:21:9;13102:2;13082:18;;;13075:30;13141:33;13121:18;;;13114:61;13192:18;;2445:63:6;13035:181:9;2445:63:6;1744:1;2583:7;:18;2321:287::o;5693:2158:8:-;-1:-1:-1;;;;;5853:18:8;5838:34;;5807:28;5838:34;;;:14;:34;;;;;;;5928:18;5913:34;;;;;;;;6003:18;5988:34;;;;;;;;6078:18;6063:34;;;;;;;;;5838;;5913;;6147:356;5838:34;5913;5988;6063;6147:31;:356::i;:::-;6108:395;;6553:1;6522:28;:32;6514:65;;;;-1:-1:-1;;;6514:65:8;;10766:2:9;6514:65:8;;;10748:21:9;10805:2;10785:18;;;10778:30;-1:-1:-1;;;10824:18:9;;;10817:50;10884:18;;6514:65:8;10738:170:9;6514:65:8;6590:28;6658;6632:22;:20;:22::i;:::-;6622:32;;:7;:32;:::i;:::-;6621:65;;;;:::i;:::-;6590:96;;6696:28;6764;6738:22;:20;:22::i;:::-;6728:32;;:7;:32;:::i;:::-;6727:65;;;;:::i;:::-;6696:96;;6802:28;6870;6844:22;:20;:22::i;:::-;6834:32;;:7;:32;:::i;:::-;6833:65;;;;:::i;:::-;6802:96;-1:-1:-1;6908:28:8;6976;6940:32;4726:1;6940:7;:32;:::i;:::-;6939:65;;;;:::i;:::-;6908:96;-1:-1:-1;7019:24:8;;7015:199;;7194:20;7158:33;7171:20;-1:-1:-1;;;7158:33:8;:::i;:::-;:56;;;;:::i;:::-;7057:38;:58;7096:18;-1:-1:-1;;;;;7057:58:8;-1:-1:-1;;;;;7057:58:8;;;;;;;;;;;;:81;7116:21;-1:-1:-1;;;;;7057:81:8;-1:-1:-1;;;;;7057:81:8;;;;;;;;;;;;;:157;;;;;;;:::i;:::-;;;;-1:-1:-1;;7015:199:8;7229:24;;7225:199;;7404:20;7368:33;7381:20;-1:-1:-1;;;7368:33:8;:::i;:::-;:56;;;;:::i;:::-;7267:38;:58;7306:18;-1:-1:-1;;;;;7267:58:8;-1:-1:-1;;;;;7267:58:8;;;;;;;;;;;;:81;7326:21;-1:-1:-1;;;;;7267:81:8;-1:-1:-1;;;;;7267:81:8;;;;;;;;;;;;;:157;;;;;;;:::i;:::-;;;;-1:-1:-1;;7225:199:8;7439:24;;7435:199;;7614:20;7578:33;7591:20;-1:-1:-1;;;7578:33:8;:::i;:::-;:56;;;;:::i;:::-;7477:38;:58;7516:18;-1:-1:-1;;;;;7477:58:8;-1:-1:-1;;;;;7477:58:8;;;;;;;;;;;;:81;7536:21;-1:-1:-1;;;;;7477:81:8;-1:-1:-1;;;;;7477:81:8;;;;;;;;;;;;;:157;;;;;;;:::i;:::-;;;;-1:-1:-1;;7435:199:8;7649:24;;7645:199;;7824:20;7788:33;7801:20;-1:-1:-1;;;7788:33:8;:::i;:::-;:56;;;;:::i;:::-;7687:38;:58;7726:18;-1:-1:-1;;;;;7687:58:8;-1:-1:-1;;;;;7687:58:8;;;;;;;;;;;;:81;7746:21;-1:-1:-1;;;;;7687:81:8;-1:-1:-1;;;;;7687:81:8;;;;;;;;;;;;;:157;;;;;;;:::i;:::-;;;;-1:-1:-1;;7645:199:8;5796:2055;;;;;;;;;5693:2158;;:::o;945:241:7:-;1110:68;;;-1:-1:-1;;;;;5853:15:9;;;1110:68:7;;;5835:34:9;5905:15;;5885:18;;;5878:43;5937:18;;;;5930:34;;;1110:68:7;;;;;;;;;;5770:18:9;;;;1110:68:7;;;;;;;;-1:-1:-1;;;;;1110:68:7;-1:-1:-1;;;1110:68:7;;;1083:96;;1103:5;;1083:19;:96::i;:::-;945:241;;;;:::o;11523:112:1:-;11583:7;11609:19;11617:3;4537:18;;4455:107;11268:534:8;11396:7;11405;11414:6;11422:5;11429;11436:7;11454:14;11478;11502:15;11527;11552:17;11579:10;11677:26;-1:-1:-1;;;;;11677:36:8;;11714:8;11677:46;;;;;;;;;;;;;13718:25:9;;13706:2;13691:18;;13673:76;11677:46:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11600:123;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;11600:123:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11742:6;11750;11758:3;11763:9;11774;11785;11734:61;;;;;;;;;;;;;;;;;;11268:534;;;;;;;:::o;2206:404:1:-;2269:4;4343:19;;;:12;;;:19;;;;;;2285:319;;-1:-1:-1;2327:23:1;;;;;;;;:11;:23;;;;;;;;;;;;;2507:18;;2485:19;;;:12;;;:19;;;;;;:40;;;;2539:11;;2285:319;-1:-1:-1;2588:5:1;2581:12;;4904:118;4971:7;4997:3;:11;;5009:5;4997:18;;;;;;;;:::i;:::-;;;;;;;;;4990:25;;4904:118;;;;:::o;14968:349:8:-;15070:7;15090:14;15107:79;15121:17;15140:18;15160:25;15107:13;:79::i;:::-;-1:-1:-1;;;;;12018:54:8;;;;;;;:38;:54;;;;;;;;12073:18;12018:74;;;;;;;;;;;;11933:34;;;:15;:34;;;;;;;;:70;:159;15090:96;-1:-1:-1;15196:91:8;11808:291;15323:349;15425:7;15445:14;15462:79;15476:17;15495:18;15515:25;15462:13;:79::i;:::-;15445:96;;15551:91;15597:17;15616:25;-1:-1:-1;;;;;12315:54:8;;;;;;;:38;:54;;;;;;;;12370:18;12315:74;;;;;;;;;;;;12230:34;;;:15;:34;;;;;:70;:159;12105:291;15678:349;15780:7;15800:14;15817:79;15831:17;15850:18;15870:25;15817:13;:79::i;:::-;15800:96;;15906:91;15952:17;15971:25;-1:-1:-1;;;;;12612:54:8;;;;;;;:38;:54;;;;;;;;12667:18;12612:74;;;;;;;;;;;;12527:34;;;:15;:34;;;:70;;:159;12402:291;16033:349;16135:7;16155:14;16172:79;16186:17;16205:18;16225:25;16172:13;:79::i;:::-;16155:96;;16261:91;16307:17;16326:25;-1:-1:-1;;;;;12909:54:8;;;;;;;:38;:54;;;;;;;;12964:18;12909:74;;;;;;;;;;;;12824:34;;;:15;:34;;;:70;;:159;12699:291;11082:135:1;11152:4;11175:35;11183:3;11203:5;11175:7;:35::i;3718:706:7:-;4137:23;4163:69;4191:4;4163:69;;;;;;;;;;;;;;;;;4171:5;-1:-1:-1;;;;;4163:27:7;;;:69;;;;;:::i;:::-;4246:17;;4137:95;;-1:-1:-1;4246:21:7;4242:176;;4341:10;4330:30;;;;;;;;;;;;:::i;:::-;4322:85;;;;-1:-1:-1;;;4322:85:7;;12240:2:9;4322:85:7;;;12222:21:9;12279:2;12259:18;;;12252:30;12318:34;12298:18;;;12291:62;-1:-1:-1;;;12369:18:9;;;12362:40;12419:19;;4322:85:7;12212:232:9;2778:1388:1;2844:4;2981:19;;;:12;;;:19;;;;;;3015:15;;3011:1149;;3384:21;3408:14;3421:1;3408:10;:14;:::i;:::-;3456:18;;3384:38;;-1:-1:-1;3436:17:1;;3456:22;;3477:1;;3456:22;:::i;:::-;3436:42;;3510:13;3497:9;:26;3493:398;;3543:17;3563:3;:11;;3575:9;3563:22;;;;;;;;:::i;:::-;;;;;;;;;3543:42;;3714:9;3685:3;:11;;3697:13;3685:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;3797:23;;;:12;;;:23;;;;;:36;;;3493:398;3969:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;4061:3;:12;;:19;4074:5;4061:19;;;;;;;;;;;4054:26;;;4102:4;4095:11;;;;;;;3011:1149;4144:5;4137:12;;;;;3872:223:0;4005:12;4036:52;4058:6;4066:4;4072:1;4075:12;4005;5240;5254:23;5281:6;-1:-1:-1;;;;;5281:11:0;5300:5;5307:4;5281:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5239:73;;;;5329:69;5356:6;5364:7;5373:10;5385:12;7645;7673:7;7669:418;;;7700:17;;7696:286;;-1:-1:-1;;;;;1465:19:0;;;7907:60;;;;-1:-1:-1;;;7907:60:0;;11115:2:9;7907:60:0;;;11097:21:9;11154:2;11134:18;;;11127:30;11193:31;11173:18;;;11166:59;11242:18;;7907:60:0;11087:179:9;7907:60:0;-1:-1:-1;8002:10:0;7995:17;;7669:418;8043:33;8051:10;8063:12;8774:17;;:21;8770:379;;9002:10;8996:17;9058:15;9045:10;9041:2;9037:19;9030:44;8770:379;9125:12;9118:20;;-1:-1:-1;;;9118:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:138:9:-;93:13;;115:31;93:13;115:31;:::i;:::-;74:78;;;:::o;157:164::-;234:13;;287:1;276:20;;;266:31;;256:2;;311:1;308;301:12;326:192;405:13;;-1:-1:-1;;;;;447:46:9;;437:57;;427:2;;508:1;505;498:12;523:165;601:13;;654:8;643:20;;633:31;;623:2;;678:1;675;668:12;693:247;752:6;805:2;793:9;784:7;780:23;776:32;773:2;;;821:1;818;811:12;773:2;860:9;847:23;879:31;904:5;879:31;:::i;945:388::-;1013:6;1021;1074:2;1062:9;1053:7;1049:23;1045:32;1042:2;;;1090:1;1087;1080:12;1042:2;1129:9;1116:23;1148:31;1173:5;1148:31;:::i;:::-;1198:5;-1:-1:-1;1255:2:9;1240:18;;1227:32;1268:33;1227:32;1268:33;:::i;:::-;1320:7;1310:17;;;1032:301;;;;;:::o;1338:456::-;1415:6;1423;1431;1484:2;1472:9;1463:7;1459:23;1455:32;1452:2;;;1500:1;1497;1490:12;1452:2;1539:9;1526:23;1558:31;1583:5;1558:31;:::i;:::-;1608:5;-1:-1:-1;1665:2:9;1650:18;;1637:32;1678:33;1637:32;1678:33;:::i;:::-;1442:352;;1730:7;;-1:-1:-1;;;1784:2:9;1769:18;;;;1756:32;;1442:352::o;1799:936::-;1896:6;1904;1912;1920;1928;1981:3;1969:9;1960:7;1956:23;1952:33;1949:2;;;1998:1;1995;1988:12;1949:2;2037:9;2024:23;2056:31;2081:5;2056:31;:::i;:::-;2106:5;-1:-1:-1;2163:2:9;2148:18;;2135:32;2176:33;2135:32;2176:33;:::i;:::-;2228:7;-1:-1:-1;2282:2:9;2267:18;;2254:32;;-1:-1:-1;2337:2:9;2322:18;;2309:32;2360:18;2390:14;;;2387:2;;;2417:1;2414;2407:12;2387:2;2455:6;2444:9;2440:22;2430:32;;2500:7;2493:4;2489:2;2485:13;2481:27;2471:2;;2522:1;2519;2512:12;2471:2;2562;2549:16;2588:2;2580:6;2577:14;2574:2;;;2604:1;2601;2594:12;2574:2;2649:7;2644:2;2635:6;2631:2;2627:15;2623:24;2620:37;2617:2;;;2670:1;2667;2660:12;2617:2;1939:796;;;;-1:-1:-1;1939:796:9;;-1:-1:-1;2701:2:9;2693:11;;2723:6;1939:796;-1:-1:-1;;;1939:796:9:o;2740:315::-;2808:6;2816;2869:2;2857:9;2848:7;2844:23;2840:32;2837:2;;;2885:1;2882;2875:12;2837:2;2924:9;2911:23;2943:31;2968:5;2943:31;:::i;:::-;2993:5;3045:2;3030:18;;;;3017:32;;-1:-1:-1;;;2827:228:9:o;3060:277::-;3127:6;3180:2;3168:9;3159:7;3155:23;3151:32;3148:2;;;3196:1;3193;3186:12;3148:2;3228:9;3222:16;3281:5;3274:13;3267:21;3260:5;3257:32;3247:2;;3303:1;3300;3293:12;3342:180;3401:6;3454:2;3442:9;3433:7;3429:23;3425:32;3422:2;;;3470:1;3467;3460:12;3422:2;-1:-1:-1;3493:23:9;;3412:110;-1:-1:-1;3412:110:9:o;3527:385::-;3613:6;3621;3629;3637;3690:3;3678:9;3669:7;3665:23;3661:33;3658:2;;;3707:1;3704;3697:12;3658:2;-1:-1:-1;;3730:23:9;;;3800:2;3785:18;;3772:32;;-1:-1:-1;3851:2:9;3836:18;;3823:32;;3902:2;3887:18;3874:32;;-1:-1:-1;3648:264:9;-1:-1:-1;3648:264:9:o;3917:1186::-;4080:6;4088;4096;4104;4112;4120;4128;4136;4144;4152;4160:7;4169;4223:3;4211:9;4202:7;4198:23;4194:33;4191:2;;;4240:1;4237;4230:12;4191:2;4272:9;4266:16;4322:26;4315:5;4311:38;4304:5;4301:49;4291:2;;4364:1;4361;4354:12;4291:2;4387:5;-1:-1:-1;4411:49:9;4456:2;4441:18;;4411:49;:::i;:::-;4401:59;;4479:49;4524:2;4513:9;4509:18;4479:49;:::i;:::-;4469:59;;4547:49;4592:2;4581:9;4577:18;4547:49;:::i;:::-;4537:59;;4615:49;4659:3;4648:9;4644:19;4615:49;:::i;:::-;4605:59;;4683:48;4726:3;4715:9;4711:19;4683:48;:::i;:::-;4673:58;;4750:48;4793:3;4782:9;4778:19;4750:48;:::i;:::-;4740:58;;4817:50;4862:3;4851:9;4847:19;4817:50;:::i;:::-;4807:60;;4907:3;4896:9;4892:19;4886:26;4876:36;;4952:3;4941:9;4937:19;4931:26;4921:36;;4977:50;5022:3;5011:9;5007:19;4977:50;:::i;:::-;4966:61;;5047:50;5092:3;5081:9;5077:19;5047:50;:::i;:::-;5036:61;;4181:922;;;;;;;;;;;;;;:::o;5108:274::-;5237:3;5275:6;5269:13;5291:53;5337:6;5332:3;5325:4;5317:6;5313:17;5291:53;:::i;:::-;5360:16;;;;;5245:137;-1:-1:-1;;5245:137:9:o;7830:383::-;7979:2;7968:9;7961:21;7942:4;8011:6;8005:13;8054:6;8049:2;8038:9;8034:18;8027:34;8070:66;8129:6;8124:2;8113:9;8109:18;8104:2;8096:6;8092:15;8070:66;:::i;:::-;8197:2;8176:15;-1:-1:-1;;8172:29:9;8157:45;;;;8204:2;8153:54;;7951:262;-1:-1:-1;;7951:262:9:o;14618:128::-;14658:3;14689:1;14685:6;14682:1;14679:13;14676:2;;;14695:18;;:::i;:::-;-1:-1:-1;14731:9:9;;14666:80::o;14751:120::-;14791:1;14817;14807:2;;14822:18;;:::i;:::-;-1:-1:-1;14856:9:9;;14797:74::o;14876:422::-;14965:1;15008:5;14965:1;15022:270;15043:7;15033:8;15030:21;15022:270;;;15102:4;15098:1;15094:6;15090:17;15084:4;15081:27;15078:2;;;15111:18;;:::i;:::-;15161:7;15151:8;15147:22;15144:2;;;15181:16;;;;15144:2;15260:22;;;;15220:15;;;;15022:270;;;15026:3;14940:358;;;;;:::o;15303:131::-;15363:5;15392:36;15419:8;15413:4;15488:5;15518:8;15508:2;;-1:-1:-1;15559:1:9;15573:5;;15508:2;15607:4;15597:2;;-1:-1:-1;15644:1:9;15658:5;;15597:2;15689:4;15707:1;15702:59;;;;15775:1;15770:130;;;;15682:218;;15702:59;15732:1;15723:10;;15746:5;;;15770:130;15807:3;15797:8;15794:17;15791:2;;;15814:18;;:::i;:::-;-1:-1:-1;;15870:1:9;15856:16;;15885:5;;15682:218;;15984:2;15974:8;15971:16;15965:3;15959:4;15956:13;15952:36;15946:2;15936:8;15933:16;15928:2;15922:4;15919:12;15915:35;15912:77;15909:2;;;-1:-1:-1;16021:19:9;;;16053:5;;15909:2;16100:34;16125:8;16119:4;16100:34;:::i;:::-;16170:6;16166:1;16162:6;16158:19;16149:7;16146:32;16143:2;;;16181:18;;:::i;:::-;16219:20;;15498:747;-1:-1:-1;;;15498:747:9:o;16250:168::-;16290:7;16356:1;16352;16348:6;16344:14;16341:1;16338:21;16333:1;16326:9;16319:17;16315:45;16312:2;;;16363:18;;:::i;:::-;-1:-1:-1;16403:9:9;;16302:116::o;16423:125::-;16463:4;16491:1;16488;16485:8;16482:2;;;16496:18;;:::i;:::-;-1:-1:-1;16533:9:9;;16472:76::o;16553:258::-;16625:1;16635:113;16649:6;16646:1;16643:13;16635:113;;;16725:11;;;16719:18;16706:11;;;16699:39;16671:2;16664:10;16635:113;;;16766:6;16763:1;16760:13;16757:2;;;-1:-1:-1;;16801:1:9;16783:16;;16776:27;16606:205::o;16816:112::-;16848:1;16874;16864:2;;16879:18;;:::i;:::-;-1:-1:-1;16913:9:9;;16854:74::o;16933:127::-;16994:10;16989:3;16985:20;16982:1;16975:31;17025:4;17022:1;17015:15;17049:4;17046:1;17039:15;17065:127;17126:10;17121:3;17117:20;17114:1;17107:31;17157:4;17154:1;17147:15;17181:4;17178:1;17171:15;17197:127;17258:10;17253:3;17249:20;17246:1;17239:31;17289:4;17286:1;17279:15;17313:4;17310:1;17303:15;17329:127;17390:10;17385:3;17381:20;17378:1;17371:31;17421:4;17418:1;17411:15;17445:4;17442:1;17435:15;17461:131;-1:-1:-1;;;;;17536:31:9;;17526:42;;17516:2;;17582:1;17579;17572:12;17516:2;17506:86;:::o

ipfs://83eb88080eaa9d861645ff4b73d09a45634fa3d424b587d7dc76753e2d25184a