Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "../interfaces/IExtraReward.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "../interfaces/IGaugeV2.sol";
import "../interfaces/IGaugeController.sol";
import "./BaseGaugeV2.sol";
import "../interfaces/IVotingYFI.sol";
import "../interfaces/IDYfiRewardPool.sol";

/** @title  Gauge stake vault token get YFI rewards
    @notice Deposit your vault token (one gauge per vault).
    YFI are paid based on the number of vault tokens, the veYFI balance, and the duration of the lock.
    @dev this contract is used behind multiple delegate proxies.
 */

contract GaugeV2 is BaseGaugeV2, ERC20Upgradeable, IGaugeV2 {
    using SafeERC20 for IERC20;

    struct Balance {
        uint256 realBalance;
        uint256 boostedBalance;
    }

    struct Approved {
        bool claim;
        bool lock;
    }

    uint256 public constant BOOSTING_FACTOR = 1;
    uint256 public constant BOOST_DENOMINATOR = 10;

    IERC20 public asset;
    //// @notice veYFI
    address public constant VEYFI = 0x90c1f9220d90d3966FbeE24045EDd73E1d588aD5;
    //// @notice the veYFI YFI reward pool, penalty are sent to this contract.
    address public constant VE_YFI_POOL = 0x2391Fc8f5E417526338F5aa3968b1851C16D894E;
    uint256 public constant PRECISION_FACTOR = 10 ** 18;

    IGaugeController public controller;

    mapping(address => uint256) private _boostedBalances;
    mapping(address => address) public recipients;

    event TransferredPenalty(address indexed account, uint256 transfered);
    event BoostedBalanceUpdated(address indexed account, uint256 amount);

    event Initialize(address indexed asset, address indexed owner);

    event RecipientUpdated(address indexed account, address indexed recipient);

    constructor() initializer {}

    /** @notice initialize the contract
     *  @dev Initialize called after contract is cloned.
     *  @param _asset The vault token to stake
     *  @param _owner owner address
     *  @param _controller gauge controller
     *  @param _data additional data (unused in this version)
     */
    function initialize(address _asset, address _owner, address _controller, bytes memory _data) external initializer {
        __initialize(_owner);
        asset = IERC20(_asset);

        require(_controller != address(0), "_controller 0x0 address");
        controller = IGaugeController(_controller);

        __ERC20_init(
            string.concat("yGauge ", IERC20Metadata(_asset).name()),
            string.concat("yG-", IERC20Metadata(_asset).symbol())
        );
        emit Initialize(_asset, _owner);
    }

    /** @return total of the staked vault token
     */
    function totalAssets() public view returns (uint256) {
        return totalSupply();
    }

    /**
        The amount of shares that the Vault would exchange for the amount of assets provided.
    */
    function convertToShares(uint256 _assets) public view returns (uint256) {
        return _assets;
    }

    /**
        The amount of assets that the Vault would exchange for the amount of shares provided.
    */
    function convertToAssets(uint256 _shares) public view returns (uint256) {
        return _shares;
    }

    /**
    Maximum amount of the underlying asset that can be deposited into the Vault for the receiver, through a deposit call.
    */
    function maxDeposit(address) public view returns (uint256) {
        return type(uint256).max;
    }

    /**
    Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given current on-chain conditions.
    */
    function previewDeposit(uint256 _assets) public view returns (uint256) {
        return _assets;
    }

    /**
    Maximum amount of shares that can be minted from the Vault for the receiver, through a mint call.
    */
    function maxMint(address) public view returns (uint256) {
        return type(uint256).max;
    }

    /**
    Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given current on-chain conditions.
    */
    function previewMint(uint256 _shares) public view returns (uint256) {
        return _shares;
    }

    /** @param _account to look balance for
     *  @return amount of staked token for an account
     */
    function boostedBalanceOf(
        address _account
    ) external view returns (uint256) {
        return _boostedBalances[_account];
    }

    /** @notice
     *   Performs a snapshot of the account's accrued rewards since the previous update.
     *  @dev
     *   The snapshot made by this function depends on:
     *    1. The account's boosted balance
     *    2. The amount of reward emissions that have been added to the gauge since the
     *       account's rewards were last updated.
     *   Any function that mutates an account's balance, boostedBalance, userRewardPerTokenPaid,
     *   or rewards MUST call updateReward before performing the mutation.
     */
    function _updateReward(address _account) internal override {
        if (block.timestamp >= periodFinish && totalAssets() > 0) {
            // new epoch. first sync rewards to end of old epoch
            rewardPerTokenStored = _rewardPerToken();
            // get new rewards
            (uint256 cumulative, uint256 current, uint256 start) = controller.claim();
            uint256 delta = cumulative - current - historicalRewards;
            if (delta > 0) {
                // account for fully missed epochs, if any
                rewardPerTokenStored += delta * PRECISION_FACTOR / totalAssets();
            }
            // forward to beginning of epoch
            uint256 finish = start + DURATION;
            uint256 rate = current * PRECISION_FACTOR / DURATION;

            lastUpdateTime = start;
            periodFinish = finish;
            rewardRate = rate;
            historicalRewards = cumulative;

            emit RewardsAdded(current, start, finish, rate, cumulative);
        }

        rewardPerTokenStored = _rewardPerToken();
        lastUpdateTime = lastTimeRewardApplicable();
        if (_account != address(0)) {
            if (_boostedBalances[_account] != 0) {
                uint256 newEarning = _newEarning(_account);
                uint256 maxEarning = _maxEarning(_account);

                rewards[_account] += newEarning;
                uint256 penalty = maxEarning - newEarning;
                _transferVeYfiORewards(penalty);
                emit TransferredPenalty(_account, penalty);
            }
            userRewardPerTokenPaid[_account] = rewardPerTokenStored;
            emit UpdatedRewards(
                _account,
                rewardPerTokenStored,
                lastUpdateTime,
                rewards[_account],
                userRewardPerTokenPaid[_account]
            );
        }
    }

    function _beforeTokenTransfer(
        address _from,
        address _to,
        uint256
    ) internal override {
        if (_from != address(0)) {
            _updateReward(_from);
        }
        if (_to != address(0)) {
            _updateReward(_to);
        }
    }

    function _afterTokenTransfer(
        address _from,
        address _to,
        uint256
    ) internal override {
        if (_from != address(0)) {
            _boostedBalances[_from] = _boostedBalanceOf(_from);
            emit BoostedBalanceUpdated(_from, _boostedBalances[_from]);
        }
        if (_to != address(0)) {
            _boostedBalances[_to] = _boostedBalanceOf(_to);
            emit BoostedBalanceUpdated(_to, _boostedBalances[_to]);
        }
    }

    function _rewardPerToken() internal view override returns (uint256) {
        if (totalAssets() == 0) {
            return rewardPerTokenStored;
        }
        return
            rewardPerTokenStored +
            (((lastTimeRewardApplicable() - lastUpdateTime) *
                rewardRate) / totalAssets());
    }

    /** @notice The total undistributed earnings for an account.
     *  @dev Earnings are based on lock duration and boost
     *  @return
     *   Amount of tokens the account has earned that have yet to be distributed.
     */
    function earned(
        address _account
    ) external view override(BaseGaugeV2, IBaseGauge) returns (uint256) {
        uint256 newEarning = _newEarning(_account);

        return newEarning + rewards[_account];
    }

    /** @notice Calculates an account's earnings based on their boostedBalance.
     *   This function only reflects the accounts earnings since the last time
     *   the account's rewards were calculated via _updateReward.
     */
    function _newEarning(
        address _account
    ) internal view override returns (uint256) {
        return
            (_boostedBalances[_account] *
                (_rewardPerToken() - userRewardPerTokenPaid[_account])) /
            PRECISION_FACTOR;
    }

    /** @notice Calculates an account's potential maximum earnings based on
     *   a maximum boost.
     *   This function only reflects the accounts earnings since the last time
     *   the account's rewards were calculated via _updateReward.
     */
    function _maxEarning(address _account) internal view returns (uint256) {
        return
            (balanceOf(_account) *
                (_rewardPerToken() - userRewardPerTokenPaid[_account])) /
            PRECISION_FACTOR;
    }

    /** @notice
     *   Calculates the boosted balance of based on veYFI balance.
     *  @dev
     *   This function expects this._totalAssets to be up to date.
     *  @return
     *   The account's boosted balance. Always lower than or equal to the
     *   account's real balance.
     */
    function nextBoostedBalanceOf(
        address _account
    ) external view returns (uint256) {
        return _boostedBalanceOf(_account);
    }

    /** @notice
     *   Calculates the boosted balance of based on veYFI balance.
     *  @dev
     *    This function expects the account's _balances[_account].realBalance
     *    to be up to date.
     *  @dev This function expects this._totalAssets to be up to date.
     *  @return
     *   The account's boosted balance. Always lower than or equal to the
     *   account's real balance.
     */
    function _boostedBalanceOf(
        address _account
    ) internal view returns (uint256) {
        return _boostedBalanceOf(_account, balanceOf(_account));
    }

    /** @notice
     *   Calculates the boosted balance of an account based on its gauge stake
     *   proportion & veYFI lock proportion.
     *  @dev This function expects this._totalAssets to be up to date.
     *  @param _account The account whose veYFI lock should be checked.
     *  @param _realBalance The amount of token _account has locked in the gauge.
     *  @return
     *   The account's boosted balance. Always lower than or equal to the
     *   account's real balance.
     */
    function _boostedBalanceOf(
        address _account,
        uint256 _realBalance
    ) internal view returns (uint256) {
        uint256 veTotalSupply = IVotingYFI(VEYFI).totalSupply();
        if (veTotalSupply == 0) {
            return _realBalance;
        }
        return
            Math.min(
                ((_realBalance * BOOSTING_FACTOR) +
                    (((totalSupply() * IVotingYFI(VEYFI).balanceOf(_account)) /
                        veTotalSupply) *
                        (BOOST_DENOMINATOR - BOOSTING_FACTOR))) /
                    BOOST_DENOMINATOR,
                _realBalance
            );
    }

    /** @notice deposit vault tokens into the gauge
     *  @dev a user without a veYFI should not lock.
     *  @dev will deposit the min between user balance and user approval
     *  @dev This call updates claimable rewards
     *  @return amount of assets deposited
     */
    function deposit() external returns (uint256) {
        uint256 balance = Math.min(
            asset.balanceOf(msg.sender),
            asset.allowance(msg.sender, address(this))
        );
        _deposit(balance, msg.sender);
        return balance;
    }

    /** @notice deposit vault tokens into the gauge
     *  @dev a user without a veYFI should not lock.
     *  @dev This call updates claimable rewards
     *  @param _assets of vault token
     *  @return amount  of assets deposited
     */
    function deposit(uint256 _assets) external returns (uint256) {
        _deposit(_assets, msg.sender);
        return _assets;
    }

    /** @notice deposit vault tokens into the gauge for a user
     *   @dev vault token is taken from msg.sender
     *   @dev This call update  `_for` claimable rewards
     *   @param _assets to deposit
     *   @param _receiver the account to deposit to
     *   @return true
     */
    function deposit(
        uint256 _assets,
        address _receiver
    ) external returns (uint256) {
        _deposit(_assets, _receiver);
        return _assets;
    }

    /** @notice deposit vault tokens into the gauge for a user
     *   @dev vault token is taken from msg.sender
     *   @dev This call update  `_for` claimable rewards
     *   @dev shares and
     *   @param _shares to deposit
     *   @param _receiver the account to deposit to
     *   @return amount of shares transfered
     */
    function mint(
        uint256 _shares,
        address _receiver
    ) external returns (uint256) {
        _deposit(_shares, _receiver);
        return _shares;
    }

    function _deposit(uint256 _assets, address _receiver) internal {
        require(_assets != 0, "RewardPool : Cannot deposit 0");

        //take away from sender
        asset.safeTransferFrom(msg.sender, address(this), _assets);

        // mint shares
        _mint(_receiver, _assets);

        emit Deposit(msg.sender, _receiver, _assets, _assets);
    }

    /**
      Maximum amount of the underlying asset that can be withdrawn from the owner balance in the Vault, through a withdraw call.
    */
    function maxWithdraw(address _owner) external view returns (uint256) {
        return balanceOf(_owner);
    }

    function previewWithdraw(uint256 _assets) external view returns (uint256) {
        return _assets;
    }

    /** @notice Burns shares from owner and sends exactly assets of underlying tokens to receiver.
     *  @dev This call updates claimable rewards
     *  @param _assets amount to withdraw
     *  @param _receiver account that will recieve the shares
     *  @param _owner shares will be taken from account
     *  @param _claim claim veYFI and additional reward
     *  @return amount of shares withdrawn
     */
    function withdraw(
        uint256 _assets,
        address _receiver,
        address _owner,
        bool _claim
    ) external returns (uint256) {
        return _withdraw(_assets, _receiver, _owner, _claim);
    }

    /** @notice Burns shares from owner and sends exactly assets of underlying tokens to receiver.
     *  @dev This call updates claimable rewards
     *  @param _assets amount to withdraw
     *  @param _receiver account that will recieve the shares
     *  @param _owner shares will be taken from account
     *  @return amount of shares withdrawn
     */
    function withdraw(
        uint256 _assets,
        address _receiver,
        address _owner
    ) external returns (uint256) {
        return _withdraw(_assets, _receiver, _owner, false);
    }

    /** @notice withdraw all vault tokens from gauge
     *   @dev This call updates claimable rewards
     *   @param _claim claim veYFI and additional reward
     *  @return amount of shares withdrawn
     */
    function withdraw(bool _claim) external returns (uint256) {
        return _withdraw(balanceOf(msg.sender), msg.sender, msg.sender, _claim);
    }

    /** @notice withdraw all vault token from gauge
     *  @dev This call update claimable rewards
     *  @return amount of shares withdrawn
     */
    function withdraw() external returns (uint256) {
        return _withdraw(balanceOf(msg.sender), msg.sender, msg.sender, false);
    }

    function _withdraw(
        uint256 _assets,
        address _receiver,
        address _owner,
        bool _claim
    ) internal returns (uint256) {
        require(_assets != 0, "RewardPool : Cannot withdraw 0");

        if (msg.sender != _owner) {
            _spendAllowance(_owner, msg.sender, _assets);
        }

        _burn(_owner, _assets);

        if (_claim) {
            _getReward(_owner);
        }

        asset.safeTransfer(_receiver, _assets);
        emit Withdraw(msg.sender, _receiver, _owner, _assets, _assets);

        return _assets;
    }

    function maxRedeem(address _owner) external view returns (uint256) {
        return balanceOf(_owner);
    }

    function previewRedeem(uint256 _assets) external view returns (uint256) {
        return _assets;
    }

    /** @notice Burns shares from owner and sends exactly assets of underlying tokens to receiver.
     *  @dev This call updates claimable rewards
     *  @param _assets amount to withdraw
     *  @param _receiver account that will recieve the shares
     *  @param _owner shares will be taken from account
     *  @return amount of shares withdrawn
     */
    function redeem(
        uint256 _assets,
        address _receiver,
        address _owner
    ) external override returns (uint256) {
        return _withdraw(_assets, _receiver, _owner, true);
    }

    /**
     * @notice
     *  Get rewards
     * @return true
     */
    function getReward() external updateReward(msg.sender) returns (bool) {
        _getReward(msg.sender);
        return true;
    }

    /**
     * @notice
     *  Get rewards for an account
     * @dev rewards are transferred to _account
     * @param _account to claim rewards for
     * @return true
     */
    function getReward(
        address _account
    ) external updateReward(_account) returns (bool) {
        _getReward(_account);

        return true;
    }

    /** @notice Distributes the rewards for the specified account.
     *  @dev
     *   This function MUST NOT be called without the caller invoking
     *   updateReward(_account) first.
     */
    function _getReward(address _account) internal {
        uint256 boostedBalance = _boostedBalanceOf(_account);
        _boostedBalances[_account] = boostedBalance;
        emit BoostedBalanceUpdated(_account, boostedBalance);

        uint256 reward = rewards[_account];
        if (reward != 0) {
            rewards[_account] = 0;
            address recipient = recipients[_account];
            if (recipient != address(0x0)) {
                REWARD_TOKEN.safeTransfer(recipient, reward);
            } else {
                REWARD_TOKEN.safeTransfer(_account, reward);
            }
            emit RewardPaid(_account, reward);
        }
    }

    function _transferVeYfiORewards(uint256 _penalty) internal {
        IERC20(REWARD_TOKEN).approve(VE_YFI_POOL, _penalty);
        IDYfiRewardPool(VE_YFI_POOL).burn(_penalty);
    }

    function _protectedTokens(
        address _token
    ) internal view override returns (bool) {
        return _token == address(REWARD_TOKEN) || _token == address(asset);
    }

    /**
    @notice Kick `addr` for abusing their boost
    @param _accounts Addresses to kick
    */
    function kick(address[] calldata _accounts) public {
        for (uint256 i = 0; i < _accounts.length; ++i) {
            _kick(_accounts[i]);
        }
    }

    function _kick(address _account) internal updateReward(_account) {
        uint256 balance = balanceOf(_account);
        uint256 boostedBalance = _boostedBalanceOf(_account, balance);
        _boostedBalances[_account] = boostedBalance;
        emit BoostedBalanceUpdated(_account, boostedBalance);
    }

    /**
    @notice Set the recipient of rewards for an account
    @param _recipient Address to send rewards to
    */
    function setRecipient(address _recipient) external {
        recipients[msg.sender] = _recipient;
        emit RecipientUpdated(msg.sender, _recipient);
    }

    /**
    @notice set the new gauge controller
    @param _newController new gauge controller address
     */
    function setController(
        address _newController
    ) external onlyOwner {
        require(_newController != address(0), "controller should not be empty");
        controller = IGaugeController(_newController);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "../interfaces/IBaseGauge.sol";

abstract contract BaseGaugeV2 is IBaseGauge, OwnableUpgradeable {
    IERC20 public constant REWARD_TOKEN = IERC20(0x41252E8691e964f7DE35156B68493bAb6797a275);
    uint256 constant DURATION = 14 days;
    uint256 public periodFinish;
    uint256 public rewardRate;
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;
    uint256 public historicalRewards;

    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;

    event RewardsAdded(
        uint256 currentRewards,
        uint256 lastUpdateTime,
        uint256 periodFinish,
        uint256 rewardRate,
        uint256 historicalRewards
    );

    event RewardsQueued(address indexed from, uint256 amount);

    event RewardPaid(address indexed user, uint256 reward);
    event UpdatedRewards(
        address indexed account,
        uint256 rewardPerTokenStored,
        uint256 lastUpdateTime,
        uint256 rewards,
        uint256 userRewardPerTokenPaid
    );
    event Sweep(address indexed token, uint256 amount);

    function _newEarning(address) internal view virtual returns (uint256);

    function _updateReward(address) internal virtual;

    function _rewardPerToken() internal view virtual returns (uint256);

    modifier updateReward(address account) {
        _updateReward(account);
        _;
    }

    function __initialize(address _owner) internal {
        require(_owner != address(0), "_owner 0x0 address");
        _transferOwnership(_owner);
    }

    /**
     *  @return timestamp until rewards are distributed
     */
    function lastTimeRewardApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, periodFinish);
    }

    /** @notice reward per token deposited
     *  @dev gives the total amount of rewards distributed since the inception of the pool.
     *  @return rewardPerToken
     */
    function rewardPerToken() external view returns (uint256) {
        return _rewardPerToken();
    }

    function _protectedTokens(
        address _token
    ) internal view virtual returns (bool) {
        return _token == address(REWARD_TOKEN);
    }

    /** @notice sweep tokens that are airdropped/transferred into the gauge.
     *  @dev sweep can only be done on non-protected tokens.
     *  @return _token to sweep
     */
    function sweep(address _token) external onlyOwner returns (bool) {
        require(_protectedTokens(_token) == false, "protected token");
        uint256 amount = IERC20(_token).balanceOf(address(this));

        SafeERC20.safeTransfer(IERC20(_token), owner(), amount);
        emit Sweep(_token, amount);
        return true;
    }

    /** @notice earnings for an account
     *  @dev earnings are based on lock duration and boost
     *  @return amount of tokens earned
     */
    function earned(address _account) external view virtual returns (uint256) {
        return _newEarning(_account);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IBaseGauge {
    function earned(address _account) external view returns (uint256);
}

// 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 (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/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");
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-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.8.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://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (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.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

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

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

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

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

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

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

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

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

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

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized < type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @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://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (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 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
pragma solidity 0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IBaseGauge.sol";

interface IExtraReward is IBaseGauge {
    function initialize(
        address _gauge,
        address _reward,
        address _owner
    ) external;

    function rewardCheckpoint(address _account) external returns (bool);

    function getReward() external returns (bool);
}

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

interface IDYfiRewardPool {
    function burn(uint256 _amount) external returns (bool);
}

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

interface IGaugeController {
    function claim() external returns (uint256, uint256, uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IVotingYFI is IERC20 {
    struct LockedBalance {
        int128 amount;
        uint256 end;
    }

    function totalSupply() external view returns (uint256);

    function locked(address _user) external view returns (LockedBalance memory);

    function modify_lock(
        uint256 _amount,
        uint256 _unlock_time,
        address _user
    ) external;
}

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

pragma solidity ^0.8.0;

import "./IERC20Upgradeable.sol";
import "./extensions/IERC20MetadataUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../proxy/utils/Initializable.sol";

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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

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

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

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

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

        _afterTokenTransfer(account, address(0), amount);
    }

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

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

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

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

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[45] private __gap;
}

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

pragma solidity ^0.8.0;

import "../IERC20Upgradeable.sol";

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @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
pragma solidity 0.8.15;
import "./IBaseGauge.sol";
import "./IERC4626.sol";

interface IGaugeV2 is IBaseGauge, IERC4626 {
    function initialize(address _stakingToken, address _owner, address _controller, bytes memory _data) external;

    function boostedBalanceOf(address _account) external view returns (uint256);

    function getReward(address _account) external returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/**
 * @title EIP 4626 specification
 * @notice Interface of EIP 4626 Interface
 * as defined in https://eips.ethereum.org/EIPS/eip-4626
 */
interface IERC4626 is IERC20Upgradeable {
    /**
     * @notice Event indicating that `caller` exchanged `assets` for `shares`, and transferred those `shares` to `owner`
     * @dev Emitted when tokens are deposited into the vault via {mint} and {deposit} methods
     */
    event Deposit(
        address indexed caller,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    /**
     * @notice Event indicating that `caller` exchanged `shares`, owned by `owner`, for `assets`, and transferred those
     * `assets` to `receiver`
     * @dev Emitted when shares are withdrawn from the vault via {redeem} or {withdraw} methods
     */
    event Withdraw(
        address indexed caller,
        address indexed receiver,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    /**
     * @notice Returns the address of the underlying token used by the Vault
     * @return assetTokenAddress The address of the underlying ERC20 Token
     * @dev MUST be an ERC-20 token contract
     *
     * MUST not revert
     */
    function asset() external view returns (IERC20 assetTokenAddress);

    /**
     * @notice Returns the total amount of the underlying asset managed by the Vault
     * @return totalManagedAssets Amount of the underlying asset
     * @dev Should include any compounding that occurs from yield.
     *
     * Should be inclusive of any fees that are charged against assets in the vault.
     *
     * Must not revert
     *
     */
    function totalAssets() external view returns (uint256 totalManagedAssets);

    /**
     *
     * @notice Returns the amount of shares that, in an ideal scenario, the vault would exchange for the amount of assets
     * provided
     *
     * @param _assets Amount of assets to convert
     * @return shares Amount of shares that would be exchanged for the provided amount of assets
     *
     * @dev MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     *
     * MUST NOT show any variations depending on the caller.
     *
     * MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     *
     * MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     *
     * MUST round down towards 0.
     *
     * This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and from.
     */
    function convertToShares(
        uint256 _assets
    ) external view returns (uint256 shares);

    /**
     *
     * @notice Returns the amount of assets that the vault would exchange for the amount of shares provided
     *
     * @param _shares Amount of vault shares to convert
     * @return assets Amount of assets that would be exchanged for the provided amount of shares
     *
     * @dev MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     *
     * MUST NOT show any variations depending on the caller.
     *
     * MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     *
     * MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
     *
     * MUST round down towards 0.
     *
     * This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and from.
     */
    function convertToAssets(
        uint256 _shares
    ) external view returns (uint256 assets);

    /**
     *
     * @notice Returns the maximum amount of the underlying asset that can be deposited into the vault for the `receiver`
     * through a {deposit} call
     *
     * @param _receiver Address whose maximum deposit is being queries
     * @return maxAssets
     *
     * @dev MUST return the maximum amount of assets {deposit} would allow to be deposited for receiver and not cause a
     * revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if
     *necessary). This assumes that the user has infinite assets, i.e. MUST NOT rely on {balanceOf} of asset.
     *
     * MUST factor in both global and user-specific limits, like if deposits are entirely disabled (even temporarily)
     * it MUST return 0.
     *
     * MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
     *
     * MUST NOT revert.
     */
    function maxDeposit(
        address _receiver
    ) external view returns (uint256 maxAssets);

    /**
     * @notice Simulate the effects of a user's deposit at the current block, given current on-chain conditions
     * @param _assets Amount of assets
     * @return shares Amount of shares
     * @dev MUST return as close to and no more than the exact amount of Vault shares that would be minted in a {deposit}
     * call in the same transaction. I.e. deposit should return the same or more shares as {previewDeposit} if called in
     * the same transaction. (I.e. {previewDeposit} should underestimate or round-down)
     *
     * MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
     * deposit would be accepted, regardless if the user has enough tokens approved, etc.
     *
     * MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     *
     * MUST NOT revert due to vault specific user/global limits. MAY revert due to other conditions that would also
     * cause deposit to revert.
     *
     * Note that any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage
     * in share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewDeposit(
        uint256 _assets
    ) external view returns (uint256 shares);

    /**
     * @notice Mints `shares` Vault shares to `receiver` by depositing exactly `amount` of underlying tokens
     * @param _assets Amount of assets
     * @param _receiver Address to deposit underlying tokens into
     * @dev Must emit the {Deposit} event
     *
     * MUST support ERC-20 {approve} / {transferFrom} on asset as a deposit flow. MAY support an additional flow in
     * which the underlying tokens are owned by the Vault contract before the {deposit} execution, and are accounted for
     * during {deposit}.
     *
     * MUST revert if all of `assets` cannot be deposited (due to deposit limit being reached, slippage, the user not
     * approving enough underlying tokens to the Vault contract, etc).
     *
     * Note that most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function deposit(
        uint256 _assets,
        address _receiver
    ) external returns (uint256 shares);

    /**
     * @notice Returns the maximum amount of shares that can be minted from the vault for the `receiver``, via a `mint`
     * call
     * @param _receiver Address to deposit minted shares into
     * @return maxShares The maximum amount of shares
     * @dev MUST return the maximum amount of shares mint would allow to be deposited to receiver and not cause a revert,
     * which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if necessary).
     * This assumes that the user has infinite assets, i.e. MUST NOT rely on balanceOf of asset.
     *
     * MUST factor in both global and user-specific limits, like if mints are entirely disabled (even temporarily) it
     *
     * MUST return 0.
     *
     * MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
     *
     * MUST NOT revert.
     */
    function maxMint(
        address _receiver
    ) external view returns (uint256 maxShares);

    /**
     * @notice Simulate the effects of a user's mint at the current block, given current on-chain conditions
     * @param _shares Amount of shares to mint
     * @return assets Amount of assets required to mint `mint` amount of shares
     * @dev MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
     * in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the same
     * transaction. (I.e. {previewMint} should overestimate or round-up)
     *
     * MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
     * would be accepted, regardless if the user has enough tokens approved, etc.
     *
     * MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     *
     * MUST NOT revert due to vault specific user/global limits. MAY revert due to other conditions that would also
     * cause mint to revert.
     *
     * Note that any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by minting.
     */
    function previewMint(
        uint256 _shares
    ) external view returns (uint256 assets);

    /**
     * @notice Mints exactly `shares` vault shares to `receiver` by depositing `amount` of underlying tokens
     * @param _shares Amount of shares to mint
     * @param _receiver Address to deposit minted shares into
     * @return assets Amount of assets transferred to vault
     * @dev Must emit the {Deposit} event
     *
     * MUST support ERC-20 {approve} / {transferFrom} on asset as a mint flow. MAY support an additional flow in
     *  which the underlying tokens are owned by the Vault contract before the mint execution, and are accounted for
     * during mint.
     *
     * MUST revert if all of `shares` cannot be minted (due to deposit limit being reached, slippage, the user not
     * approving enough underlying tokens to the Vault contract, etc).
     *
     * Note that most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function mint(
        uint256 _shares,
        address _receiver
    ) external returns (uint256 assets);

    /**
     * @notice Returns the maximum amount of the underlying asset that can be withdrawn from the `owner` balance in the
     * vault, through a `withdraw` call.
     * @param _owner Address of the owner whose max withdrawal amount is being queries
     * @return maxAssets Maximum amount of underlying asset that can be withdrawn
     * @dev MUST return the maximum amount of assets that could be transferred from `owner` through {withdraw} and not
     * cause a revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if
     * necessary).
     *
     * MUST factor in both global and user-specific limits, like if withdrawals are entirely disabled
     * (even temporarily)  it MUST return 0.
     *
     * MUST NOT revert.
     */
    function maxWithdraw(
        address _owner
    ) external view returns (uint256 maxAssets);

    /**
     * @notice Simulate the effects of a user's withdrawal at the current block, given current on-chain conditions.
     * @param _assets Amount of assets
     * @return shares Amount of shares
     * @dev MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a
     * {withdraw} call in the same transaction. I.e. {withdraw} should return the same or fewer shares as
     * {previewWithdraw} if called in the same transaction. (I.e. {previewWithdraw should overestimate or round-up})
     *
     * MUST NOT account for withdrawal limits like those returned from {maxWithdraw} and should always act as though
     * the withdrawal would be accepted, regardless if the user has enough shares, etc.
     *
     * MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     *
     * MUST NOT revert due to vault specific user/global limits. MAY revert due to other conditions that would also
     * cause {withdraw} to revert.
     *
     * Note that any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewWithdraw(
        uint256 _assets
    ) external view returns (uint256 shares);

    /**
     * @notice Burns `shares` from `owner` and sends exactly `assets` of underlying tokens to `receiver`
     * @param _assets Amount of underling assets to withdraw
     * @return shares Amount of shares that will be burned
     * @dev Must emit the {Withdraw} event
     *
     * MUST support a withdraw flow where the shares are burned from `owner` directly where `owner` is `msg.sender`
     * or `msg.sender` has ERC-20 approval over the shares of `owner`. MAY support an additional flow in which the shares
     * are transferred to the Vault contract before the withdraw execution, and are accounted for during withdraw.
     *
     * MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
     * not having enough shares, etc).
     *
     * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     *  Those methods should be performed separately.
     */
    function withdraw(
        uint256 _assets,
        address _receiver,
        address _owner
    ) external returns (uint256 shares);

    /**
     * @notice Returns the maximum amount of vault shares that can be redeemed from the `owner` balance in the vault, via
     * a `redeem` call.
     * @param _owner Address of the owner whose shares are being queries
     * @return maxShares Maximum amount of shares that can be redeemed
     * @dev MUST return the maximum amount of shares that could be transferred from `owner` through `redeem` and not cause
     * a revert, which MUST NOT be higher than the actual maximum that would be accepted (it should underestimate if
     * necessary).
     *
     * MUST factor in both global and user-specific limits, like if redemption is entirely disabled
     * (even temporarily) it MUST return 0.
     *
     * MUST NOT revert
     */
    function maxRedeem(
        address _owner
    ) external view returns (uint256 maxShares);

    /**
     * @notice Simulate the effects of a user's redemption at the current block, given current on-chain conditions
     * @param _shares Amount of shares that are being simulated to be redeemed
     * @return assets Amount of underlying assets that can be redeemed
     * @dev MUST return as close to and no more than the exact amount of `assets `that would be withdrawn in a {redeem}
     * call in the same transaction. I.e. {redeem} should return the same or more assets as {previewRedeem} if called in
     * the same transaction. I.e. {previewRedeem} should underestimate/round-down
     *
     * MUST NOT account for redemption limits like those returned from {maxRedeem} and should always act as though
     * the redemption would be accepted, regardless if the user has enough shares, etc.
     *
     * MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     *
     * MUST NOT revert due to vault specific user/global limits. MAY revert due to other conditions that would also
     * cause {redeem} to revert.
     *
     * Note that any unfavorable discrepancy between {convertToAssets} and {previewRedeem} SHOULD be considered
     * slippage in share price or some other type of condition, meaning the depositor will lose assets by redeeming.
     */
    function previewRedeem(
        uint256 _shares
    ) external view returns (uint256 assets);

    /**
     * @notice Burns exactly `shares` from `owner` and sends `assets` of underlying tokens to `receiver`
     * @param _shares Amount of shares to burn
     * @param _receiver Address to deposit redeemed underlying tokens to
     * @return assets Amount of underlying tokens redeemed
     * @dev Must emit the {Withdraw} event
     * MUST support a {redeem} flow where the shares are burned from owner directly where `owner` is `msg.sender` or
     *
     * `msg.sender` has ERC-20 approval over the shares of `owner`. MAY support an additional flow in which the shares
     * are transferred to the Vault contract before the {redeem} execution, and are accounted for during {redeem}.
     *
     * MUST revert if all of {shares} cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
     * not having enough shares, etc).
     *
     * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     * Those methods should be performed separately.
     */
    function redeem(
        uint256 _shares,
        address _receiver,
        address _owner
    ) external returns (uint256 assets);
}

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

pragma solidity ^0.8.0;

import "../IERC20.sol";

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

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

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

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "remappings": [
    "@openzeppelin/contracts-upgradeable=.cache/openzeppelin-upgradeable/v4.8.1",
    "@openzeppelin/contracts=.cache/openzeppelin/v4.8.1"
  ]
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BoostedBalanceUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"}],"name":"Initialize","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"}],"name":"RecipientUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"currentRewards","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastUpdateTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"periodFinish","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"historicalRewards","type":"uint256"}],"name":"RewardsAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsQueued","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Sweep","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"transfered","type":"uint256"}],"name":"TransferredPenalty","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewardPerTokenStored","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastUpdateTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewards","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"userRewardPerTokenPaid","type":"uint256"}],"name":"UpdatedRewards","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BOOSTING_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BOOST_DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRECISION_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REWARD_TOKEN","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VEYFI","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VE_YFI_POOL","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"asset","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"boostedBalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"contract IGaugeController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"convertToAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"}],"name":"convertToShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"historicalRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_controller","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_accounts","type":"address[]"}],"name":"kick","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"maxRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"maxWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"nextBoostedBalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"previewMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"recipients","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"address","name":"_owner","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newController","type":"address"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"setRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"sweep","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_claim","type":"bool"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"address","name":"_owner","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"bool","name":"_claim","type":"bool"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

909:19745:14:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8463:221;;;;;;:::i;:::-;;:::i;:::-;;;529:25:22;;;517:2;502:18;8463:221:14;;;;;;;;2688:332:13;;;;;;:::i;:::-;;:::i;:::-;;;730:14:22;;723:22;705:41;;693:2;678:18;2688:332:13;565:187:22;2976:90:14;;;:::i;2491:98:2:-;;;:::i;:::-;;;;;;;:::i;796:42:13:-;;;;;;:::i;:::-;;;;;;;;;;;;;;3399:103:14;;;;;;:::i;:::-;3488:7;3399:103;4768:197:2;;;;;;:::i;:::-;;:::i;19558:158:14:-;;;;;;:::i;:::-;;:::i;:::-;;3579:106:2;3666:12;;3579:106;;1214:46:14;;1258:2;1214:46;;4595:140;;;;;;:::i;:::-;-1:-1:-1;;;;;4702:26:14;4676:7;4702:26;;;:16;:26;;;;;;;4595:140;5527:286:2;;;;;;:::i;:::-;;:::i;2397:517:14:-;;;;;;:::i;:::-;;:::i;694:32:13:-;;;;;;3428:91:2;;;3510:2;4449:36:22;;4437:2;4422:18;3428:91:2;4307:184:22;1267:19:14;;;;;-1:-1:-1;;;;;1267:19:14;;;;;;-1:-1:-1;;;;;4675:32:22;;;4657:51;;4645:2;4630:18;1267:19:14;4496:218:22;6208:234:2;;;;;;:::i;:::-;;:::i;20153:158:14:-;;;;;;:::i;:::-;;:::i;16179:134::-;;;:::i;17755:130::-;;;:::i;3645:100::-;;;;;;:::i;:::-;-1:-1:-1;;;3721:17:14;3645:100;13045:171;;;;;;:::i;:::-;;:::i;3743:125:2:-;;;;;;:::i;:::-;;:::i;2071:101:0:-;;;:::i;587:25:13:-;;;;;;1315:74:14;;1347:42;1315:74;;1942:129:13;;;:::i;733:57::-;;;;;;:::i;:::-;;;;;;;;;;;;;;1441:85:0;1513:6;;-1:-1:-1;;;;;1513:6:0;1441:85;;20429:223:14;;;;;;:::i;:::-;;:::i;2702:102:2:-;;;:::i;1165:43:14:-;;1207:1;1165:43;;419:88:13;;464:42;419:88;;6929:427:2;;;;;;:::i;:::-;;:::i;15876:146:14:-;;;;;;:::i;:::-;;:::i;4064:189:2:-;;;;;;:::i;:::-;;:::i;15464:195:14:-;;;;;;:::i;:::-;;:::i;1474:80::-;;1512:42;1474:80;;12620:131;;;;;;:::i;:::-;;:::i;17477:201::-;;;;;;:::i;:::-;;:::i;18069:157::-;;;;;;:::i;:::-;;:::i;9978:145::-;;;;;;:::i;:::-;;:::i;618:29:13:-;;;;;;1560:51:14;;1603:8;1560:51;;2251:99:13;;;:::i;14240:110:14:-;;;;;;:::i;:::-;;:::i;14882:217::-;;;;;;:::i;:::-;;:::i;12111:259::-;;;:::i;4311:149:2:-;;;;;;:::i;:::-;;:::i;653:35:13:-;;;;;;1717:45:14;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;1717:45:14;;;554:27:13;;;;;;2321:198:0;;;;;;:::i;:::-;;:::i;1618:34:14:-;;;;;-1:-1:-1;;;;;1618:34:14;;;8463:221;8568:7;8587:18;8608:21;8620:8;8608:11;:21::i;:::-;-1:-1:-1;;;;;8660:17:14;;;;;;:7;:17;;;;;;8587:42;;-1:-1:-1;8647:30:14;;8587:42;8647:30;:::i;:::-;8640:37;8463:221;-1:-1:-1;;;8463:221:14:o;2688:332:13:-;2747:4;1334:13:0;:11;:13::i;:::-;2771:24:13::1;2788:6;2771:16;:24::i;:::-;:33;2763:61;;;::::0;-1:-1:-1;;;2763:61:13;;7316:2:22;2763:61:13::1;::::0;::::1;7298:21:22::0;7355:2;7335:18;;;7328:30;-1:-1:-1;;;7374:18:22;;;7367:45;7429:18;;2763:61:13::1;;;;;;;;;2851:39;::::0;-1:-1:-1;;;2851:39:13;;2884:4:::1;2851:39;::::0;::::1;4657:51:22::0;2834:14:13::1;::::0;-1:-1:-1;;;;;2851:24:13;::::1;::::0;::::1;::::0;4630:18:22;;2851:39:13::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2834:56;;2901:55;2931:6;2940:7;1513:6:0::0;;-1:-1:-1;;;;;1513:6:0;;1441:85;2940:7:13::1;2949:6;2901:22;:55::i;:::-;2977:6;-1:-1:-1::0;;;;;2971:21:13::1;;2985:6;2971:21;;;;529:25:22::0;;517:2;502:18;;383:177;2971:21:13::1;;;;;;;;3009:4;3002:11;;;1357:1:0;2688:332:13::0;;;:::o;2976:90:14:-;3020:7;3046:13;3666:12:2;;;3579:106;3046:13:14;3039:20;;2976:90;:::o;2491:98:2:-;2545:13;2577:5;2570:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2491:98;:::o;4768:197::-;4851:4;929:10:6;4905:32:2;929:10:6;4921:7:2;4930:6;4905:8;:32::i;:::-;4954:4;4947:11;;;4768:197;;;;;:::o;19558:158:14:-;19624:9;19619:91;19639:20;;;19619:91;;;19680:19;19686:9;;19696:1;19686:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;19680:5;:19::i;:::-;19661:3;;;:::i;:::-;;;19619:91;;;;19558:158;;:::o;5527:286:2:-;5654:4;929:10:6;5710:38:2;5726:4;929:10:6;5741:6:2;5710:15;:38::i;:::-;5758:27;5768:4;5774:2;5778:6;5758:9;:27::i;:::-;-1:-1:-1;5802:4:2;;5527:286;-1:-1:-1;;;;5527:286:2:o;2397:517:14:-;3268:19:1;3291:13;;;;;;3290:14;;3336:34;;;;-1:-1:-1;3354:12:1;;3369:1;3354:12;;;;:16;3336:34;3335:108;;;-1:-1:-1;3415:4:1;1476:19:5;:23;;;3376:66:1;;-1:-1:-1;3425:12:1;;;;;:17;3376:66;3314:201;;;;-1:-1:-1;;;3314:201:1;;8506:2:22;3314:201:1;;;8488:21:22;8545:2;8525:18;;;8518:30;8584:34;8564:18;;;8557:62;-1:-1:-1;;;8635:18:22;;;8628:44;8689:19;;3314:201:1;8304:410:22;3314:201:1;3525:12;:16;;-1:-1:-1;;3525:16:1;3540:1;3525:16;;;3551:65;;;;3585:13;:20;;-1:-1:-1;;3585:20:1;;;;;3551:65;2521:20:14::1;2534:6;2521:12;:20::i;:::-;2551:5;:22:::0;;-1:-1:-1;;;;;;2551:22:14::1;-1:-1:-1::0;;;;;2551:22:14;;::::1;::::0;;;::::1;::::0;;;2592:25;::::1;2584:61;;;::::0;-1:-1:-1;;;2584:61:14;;8921:2:22;2584:61:14::1;::::0;::::1;8903:21:22::0;8960:2;8940:18;;;8933:30;8999:25;8979:18;;;8972:53;9042:18;;2584:61:14::1;8719:347:22::0;2584:61:14::1;2685:11;2655:10;;:42;;;;;-1:-1:-1::0;;;;;2655:42:14::1;;;;;-1:-1:-1::0;;;;;2655:42:14::1;;;;;;2708:158;2774:6;-1:-1:-1::0;;;;;2759:27:14::1;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;2759:29:14::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;2734:55;;;;;;;;:::i;:::-;;;;;;;;;;;;;2839:6;-1:-1:-1::0;;;;;2824:29:14::1;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;2824:31:14::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;2803:53;;;;;;;;:::i;:::-;;;;;;;;;;;;;2708:12;:158::i;:::-;2900:6;-1:-1:-1::0;;;;;2881:26:14::1;2892:6;-1:-1:-1::0;;;;;2881:26:14::1;;;;;;;;;;;3640:14:1::0;3636:99;;;3686:5;3670:21;;-1:-1:-1;;3670:21:1;;;3710:14;;-1:-1:-1;4449:36:22;;3710:14:1;;4437:2:22;4422:18;3710:14:1;;;;;;;3636:99;3258:483;2397:517:14;;;;:::o;6208:234:2:-;6296:4;929:10:6;6350:64:2;929:10:6;6366:7:2;6403:10;6375:25;929:10:6;6366:7:2;6375:9;:25::i;:::-;:38;;;;:::i;:::-;6350:8;:64::i;20153:158:14:-;20225:10;20214:22;;;;:10;:22;;;;;;:35;;-1:-1:-1;;;;;;20214:35:14;-1:-1:-1;;;;;20214:35:14;;;;;;;;20264:40;;20214:35;;20225:10;20264:40;;;20153:158;:::o;16179:134::-;16217:7;16243:63;16253:21;16263:10;16253:9;:21::i;:::-;16276:10;16288;16300:5;16243:9;:63::i;17755:130::-;17819:4;17798:10;1667:22:13;1681:7;1667:13;:22::i;:::-;17835::14::1;17846:10;17835;:22::i;:::-;17874:4;17867:11;;17755:130:::0;;:::o;13045:171::-;13138:7;13157:28;13166:7;13175:9;13157:8;:28::i;:::-;-1:-1:-1;13202:7:14;;13045:171;-1:-1:-1;13045:171:14:o;3743:125:2:-;-1:-1:-1;;;;;3843:18:2;3817:7;3843:18;;;:9;:18;;;;;;;3743:125::o;2071:101:0:-;1334:13;:11;:13::i;:::-;2135:30:::1;2162:1;2135:18;:30::i;:::-;2071:101::o:0;1942:129:13:-;1999:7;2025:39;2034:15;2051:12;;2025:8;:39::i;20429:223:14:-;1334:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;20527:28:14;::::1;20519:71;;;::::0;-1:-1:-1;;;20519:71:14;;10944:2:22;20519:71:14::1;::::0;::::1;10926:21:22::0;10983:2;10963:18;;;10956:30;11022:32;11002:18;;;10995:60;11072:18;;20519:71:14::1;10742:354:22::0;20519:71:14::1;20600:10;:45:::0;;-1:-1:-1;;;;;;20600:45:14::1;-1:-1:-1::0;;;;;20600:45:14;;;::::1;::::0;;;::::1;::::0;;20429:223::o;2702:102:2:-;2758:13;2790:7;2783:14;;;;;:::i;6929:427::-;7022:4;929:10:6;7022:4:2;7103:25;929:10:6;7120:7:2;7103:9;:25::i;:::-;7076:52;;7166:15;7146:16;:35;;7138:85;;;;-1:-1:-1;;;7138:85:2;;11303:2:22;7138:85:2;;;11285:21:22;11342:2;11322:18;;;11315:30;11381:34;11361:18;;;11354:62;-1:-1:-1;;;11432:18:22;;;11425:35;11477:19;;7138:85:2;11101:401:22;7138:85:2;7257:60;7266:5;7273:7;7301:15;7282:16;:34;7257:8;:60::i;15876:146:14:-;15925:7;15951:64;15961:21;15971:10;15961:9;:21::i;:::-;15984:10;15996;16008:6;15951:9;:64::i;4064:189:2:-;4143:4;929:10:6;4197:28:2;929:10:6;4214:2:2;4218:6;4197:9;:28::i;15464:195:14:-;15582:7;15608:44;15618:7;15627:9;15638:6;15646:5;15608:9;:44::i;:::-;15601:51;15464:195;-1:-1:-1;;;;15464:195:14:o;12620:131::-;12672:7;12691:29;12700:7;12709:10;12691:8;:29::i;:::-;-1:-1:-1;12737:7:14;12620:131::o;17477:201::-;17602:7;17628:43;17638:7;17647:9;17658:6;17666:4;17628:9;:43::i;18069:157::-;18161:4;18142:8;1667:22:13;1681:7;1667:13;:22::i;:::-;18177:20:14::1;18188:8;18177:10;:20::i;:::-;18215:4;18208:11;;1699:1:13;18069:157:14::0;;;;:::o;9978:145::-;10063:7;10089:27;10107:8;10089:17;:27::i;2251:99:13:-;2300:7;2326:17;:15;:17::i;14240:110:14:-;14300:7;14326:17;14336:6;14326:9;:17::i;14882:217::-;15021:7;15047:45;15057:7;15066:9;15077:6;15085;15047:9;:45::i;:::-;15040:52;14882:217;-1:-1:-1;;;;;14882:217:14:o;12111:259::-;12207:5;;:27;;-1:-1:-1;;;12207:27:14;;12223:10;12207:27;;;4657:51:22;12148:7:14;;;;12185:115;;-1:-1:-1;;;;;12207:5:14;;:15;;4630:18:22;;12207:27:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;12248:5;;:42;;-1:-1:-1;;;12248:42:14;;12264:10;12248:42;;;11719:34:22;12284:4:14;11769:18:22;;;11762:43;-1:-1:-1;;;;;12248:5:14;;;;:15;;11654:18:22;;12248:42:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;12185:8;:115::i;:::-;12167:133;;12310:29;12319:7;12328:10;12310:8;:29::i;4311:149:2:-;-1:-1:-1;;;;;4426:18:2;;;4400:7;4426:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;4311:149::o;2321:198:0:-;1334:13;:11;:13::i;:::-;-1:-1:-1;;;;;2409:22:0;::::1;2401:73;;;::::0;-1:-1:-1;;;2401:73:0;;12018:2:22;2401:73:0::1;::::0;::::1;12000:21:22::0;12057:2;12037:18;;;12030:30;12096:34;12076:18;;;12069:62;-1:-1:-1;;;12147:18:22;;;12140:36;12193:19;;2401:73:0::1;11816:402:22::0;2401:73:0::1;2484:28;2503:8;2484:18;:28::i;:::-;2321:198:::0;:::o;1186:320:5:-;-1:-1:-1;;;;;1476:19:5;;:23;;;1186:320::o;8923:262:14:-;-1:-1:-1;;;;;9113:32:14;;9008:7;9113:32;;;:22;:32;;;;;;1603:8;;9093:17;:15;:17::i;:::-;:52;;;;:::i;:::-;-1:-1:-1;;;;;9047:26:14;;;;;;:16;:26;;;;;;:99;;;;:::i;:::-;9046:132;;;;:::i;1599:130:0:-;1513:6;;-1:-1:-1;;;;;1513:6:0;929:10:6;1662:23:0;1654:68;;;;-1:-1:-1;;;1654:68:0;;12950:2:22;1654:68:0;;;12932:21:22;;;12969:18;;;12962:30;13028:34;13008:18;;;13001:62;13080:18;;1654:68:0;12748:356:22;19273:177:14;19361:4;-1:-1:-1;;;;;19384:31:14;;464:42:13;19384:31:14;;:59;;-1:-1:-1;;19437:5:14;;-1:-1:-1;;;;;19437:5:14;;;19419:24;;;;19273:177::o;763:205:10:-;902:58;;-1:-1:-1;;;;;13301:32:22;;902:58:10;;;13283:51:22;13350:18;;;13343:34;;;875:86:10;;895:5;;-1:-1:-1;;;925:23:10;13256:18:22;;902:58:10;;;;-1:-1:-1;;902:58:10;;;;;;;;;;;;;;-1:-1:-1;;;;;902:58:10;-1:-1:-1;;;;;;902:58:10;;;;;;;;;;875:19;:86::i;10841:370:2:-;-1:-1:-1;;;;;10972:19:2;;10964:68;;;;-1:-1:-1;;;10964:68:2;;13590:2:22;10964:68:2;;;13572:21:22;13629:2;13609:18;;;13602:30;13668:34;13648:18;;;13641:62;-1:-1:-1;;;13719:18:22;;;13712:34;13763:19;;10964:68:2;13388:400:22;10964:68:2;-1:-1:-1;;;;;11050:21:2;;11042:68;;;;-1:-1:-1;;;11042:68:2;;13995:2:22;11042:68:2;;;13977:21:22;14034:2;14014:18;;;14007:30;14073:34;14053:18;;;14046:62;-1:-1:-1;;;14124:18:22;;;14117:32;14166:19;;11042:68:2;13793:398:22;11042:68:2;-1:-1:-1;;;;;11121:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;11172:32;;529:25:22;;;11172:32:2;;502:18:22;11172:32:2;;;;;;;10841:370;;;:::o;19722:305:14:-;19777:8;1667:22:13;1681:7;1667:13;:22::i;:::-;19797:15:14::1;19815:19;19825:8;19815:9;:19::i;:::-;19797:37;;19844:22;19869:36;19887:8;19897:7;19869:17;:36::i;:::-;-1:-1:-1::0;;;;;19915:26:14;::::1;;::::0;;;:16:::1;:26;::::0;;;;;;:43;;;19973:47;19844:61;;-1:-1:-1;19915:26:14;-1:-1:-1;;;;;;;;;;;19973:47:14;::::1;::::0;19844:61;529:25:22;;517:2;502:18;;383:177;19973:47:14::1;;;;;;;;19787:240;;19722:305:::0;;:::o;11492:441:2:-;11622:24;11649:25;11659:5;11666:7;11649:9;:25::i;:::-;11622:52;;-1:-1:-1;;11688:16:2;:37;11684:243;;11769:6;11749:16;:26;;11741:68;;;;-1:-1:-1;;;11741:68:2;;14398:2:22;11741:68:2;;;14380:21:22;14437:2;14417:18;;;14410:30;14476:31;14456:18;;;14449:59;14525:18;;11741:68:2;14196:353:22;11741:68:2;11851:51;11860:5;11867:7;11895:6;11876:16;:25;11851:8;:51::i;:::-;11612:321;11492:441;;;:::o;7810:818::-;-1:-1:-1;;;;;7936:18:2;;7928:68;;;;-1:-1:-1;;;7928:68:2;;14756:2:22;7928:68:2;;;14738:21:22;14795:2;14775:18;;;14768:30;14834:34;14814:18;;;14807:62;-1:-1:-1;;;14885:18:22;;;14878:35;14930:19;;7928:68:2;14554:401:22;7928:68:2;-1:-1:-1;;;;;8014:16:2;;8006:64;;;;-1:-1:-1;;;8006:64:2;;15162:2:22;8006:64:2;;;15144:21:22;15201:2;15181:18;;;15174:30;15240:34;15220:18;;;15213:62;-1:-1:-1;;;15291:18:22;;;15284:33;15334:19;;8006:64:2;14960:399:22;8006:64:2;8081:38;8102:4;8108:2;8112:6;8081:20;:38::i;:::-;-1:-1:-1;;;;;8152:15:2;;8130:19;8152:15;;;:9;:15;;;;;;8185:21;;;;8177:72;;;;-1:-1:-1;;;8177:72:2;;15566:2:22;8177:72:2;;;15548:21:22;15605:2;15585:18;;;15578:30;15644:34;15624:18;;;15617:62;-1:-1:-1;;;15695:18:22;;;15688:36;15741:19;;8177:72:2;15364:402:22;8177:72:2;-1:-1:-1;;;;;8283:15:2;;;;;;;:9;:15;;;;;;8301:20;;;8283:38;;8498:13;;;;;;;;;;:23;;;;;;8547:26;;;;;;8315:6;529:25:22;;517:2;502:18;;383:177;8547:26:2;;;;;;;;8584:37;8604:4;8610:2;8614:6;8584:19;:37::i;1713:151:13:-;-1:-1:-1;;;;;1778:20:13;;1770:51;;;;-1:-1:-1;;;1770:51:13;;15973:2:22;1770:51:13;;;15955:21:22;16012:2;15992:18;;;15985:30;-1:-1:-1;;;16031:18:22;;;16024:48;16089:18;;1770:51:13;15771:342:22;2114:147:2;5363:13:1;;;;;;;5355:69;;;;-1:-1:-1;;;5355:69:1;;;;;;;:::i;:::-;2216:38:2::1;2239:5;2246:7;2216:22;:38::i;:::-;2114:147:::0;;:::o;16319:570:14:-;16459:7;16486;16497:1;16486:12;16478:55;;;;-1:-1:-1;;;16478:55:14;;16732:2:22;16478:55:14;;;16714:21:22;16771:2;16751:18;;;16744:30;16810:32;16790:18;;;16783:60;16860:18;;16478:55:14;16530:354:22;16478:55:14;16548:10;-1:-1:-1;;;;;16548:20:14;;;16544:95;;16584:44;16600:6;16608:10;16620:7;16584:15;:44::i;:::-;16649:22;16655:6;16663:7;16649:5;:22::i;:::-;16686:6;16682:55;;;16708:18;16719:6;16708:10;:18::i;:::-;16747:5;;:38;;-1:-1:-1;;;;;16747:5:14;16766:9;16777:7;16747:18;:38::i;:::-;16800:57;;;17063:25:22;;;17119:2;17104:18;;17097:34;;;-1:-1:-1;;;;;16800:57:14;;;;;;;;16809:10;;16800:57;;17036:18:22;16800:57:14;;;;;;;-1:-1:-1;16875:7:14;;16319:570;-1:-1:-1;;;16319:570:14:o;5276:1866::-;5368:12;;5349:15;:31;;:52;;;;;5400:1;5384:13;:11;:13::i;:::-;:17;5349:52;5345:939;;;5505:17;:15;:17::i;:::-;5482:20;:40;;;;5568:18;5588:15;5605:13;5622:10;;;;;;;;;-1:-1:-1;;;;;5622:10:14;-1:-1:-1;;;;;5622:16:14;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5567:73;;;;;;5654:13;5693:17;;5683:7;5670:10;:20;;;;:::i;:::-;:40;;;;:::i;:::-;5654:56;-1:-1:-1;5728:9:14;;5724:171;;5867:13;:11;:13::i;:::-;5840:24;1603:8;5840:5;:24;:::i;:::-;:40;;;;:::i;:::-;5816:20;;:64;;;;;;;:::i;:::-;;;;-1:-1:-1;;5724:171:14;5953:14;5970:16;541:7:13;5970:5:14;:16;:::i;:::-;5953:33;-1:-1:-1;6000:12:14;541:7:13;6015:26:14;1603:8;6015:7;:26;:::i;:::-;:37;;;;:::i;:::-;6067:14;:22;;;6103:12;:21;;;6138:10;:17;;;6169;:30;;;6219:54;;;17712:25:22;;;17768:2;17753:18;;17746:34;;;17796:18;;;17789:34;;;17854:2;17839:18;;17832:34;;;17897:3;17882:19;;17875:35;;;6138:17:14;;-1:-1:-1;6219:54:14;;17699:3:22;17684:19;6219:54:14;;;;;;;5403:881;;;;;;5345:939;6317:17;:15;:17::i;:::-;6294:20;:40;6361:26;:24;:26::i;:::-;6344:14;:43;-1:-1:-1;;;;;6401:22:14;;;6397:739;;-1:-1:-1;;;;;6443:26:14;;;;;;:16;:26;;;;;;:31;6439:390;;6494:18;6515:21;6527:8;6515:11;:21::i;:::-;6494:42;;6554:18;6575:21;6587:8;6575:11;:21::i;:::-;-1:-1:-1;;;;;6615:17:14;;;;;;:7;:17;;;;;:31;;6554:42;;-1:-1:-1;6636:10:14;;6615:17;;;:31;;6636:10;;6615:31;:::i;:::-;;;;-1:-1:-1;6664:15:14;;-1:-1:-1;6682:23:14;6695:10;6682;:23;:::i;:::-;6664:41;;6723:31;6746:7;6723:22;:31::i;:::-;6796:8;-1:-1:-1;;;;;6777:37:14;;6806:7;6777:37;;;;529:25:22;;517:2;502:18;;383:177;6777:37:14;;;;;;;;6476:353;;;6439:390;6877:20;;-1:-1:-1;;;;;6842:32:14;;;;;;:22;:32;;;;;;;;:55;;;7012:14;;7044:7;:17;;;;;;;7079:32;;;6916:209;;18152:25:22;;;18193:18;;;18186:34;;;;18236:18;;;18229:34;18294:2;18279:18;;18272:34;;;;6842:32:14;6916:209;;18139:3:22;18124:19;6916:209:14;;;;;;;5276:1866;:::o;18429:652::-;18486:22;18511:27;18529:8;18511:17;:27::i;:::-;-1:-1:-1;;;;;18548:26:14;;;;;;:16;:26;;;;;;;:43;;;18606:47;18486:52;;-1:-1:-1;18548:26:14;-1:-1:-1;;;;;;;;;;;18606:47:14;;;18486:52;529:25:22;;517:2;502:18;;383:177;18606:47:14;;;;;;;;-1:-1:-1;;;;;18681:17:14;;18664:14;18681:17;;;:7;:17;;;;;;18712:11;;18708:367;;-1:-1:-1;;;;;18739:17:14;;;18759:1;18739:17;;;:7;:17;;;;;;;;:21;;;18794:10;:20;;;;;;;18832:25;;18828:190;;18877:44;464:42:13;18903:9:14;18914:6;18877:25;:44::i;:::-;18828:190;;;18960:43;464:42:13;18986:8:14;18996:6;18960:25;:43::i;:::-;19047:8;-1:-1:-1;;;;;19036:28:14;;19057:6;19036:28;;;;529:25:22;;517:2;502:18;;383:177;13732:358:14;13813:7;13824:1;13813:12;13805:54;;;;-1:-1:-1;;;13805:54:14;;18519:2:22;13805:54:14;;;18501:21:22;18558:2;18538:18;;;18531:30;18597:31;18577:18;;;18570:59;18646:18;;13805:54:14;18317:353:22;13805:54:14;13902:5;;:58;;-1:-1:-1;;;;;13902:5:14;13925:10;13945:4;13952:7;13902:22;:58::i;:::-;13994:25;14000:9;14011:7;13994:5;:25::i;:::-;14035:48;;;17063:25:22;;;17119:2;17104:18;;17097:34;;;-1:-1:-1;;;;;14035:48:14;;;14043:10;;14035:48;;17036:18:22;14035:48:14;;;;;;;13732:358;;:::o;2673:187:0:-;2765:6;;;-1:-1:-1;;;;;2781:17:0;;;-1:-1:-1;;;;;;2781:17:0;;;;;;;2813:40;;2765:6;;;2781:17;2765:6;;2813:40;;2746:16;;2813:40;2736:124;2673:187;:::o;588:104:12:-;646:7;676:1;672;:5;:13;;-1:-1:-1;684:1:12;665:20;-1:-1:-1;588:104:12:o;10533:163:14:-;10615:7;10641:48;10659:8;10669:19;10679:8;10669:9;:19::i;:::-;10641:17;:48::i;7909:318::-;7968:7;7991:13;:11;:13::i;:::-;8008:1;7991:18;7987:76;;-1:-1:-1;8032:20:14;;;7909:318::o;7987:76::-;8206:13;:11;:13::i;:::-;8192:10;;8158:14;;8129:26;:24;:26::i;:::-;:43;;;;:::i;:::-;8128:74;;;;:::i;:::-;8127:92;;;;:::i;:::-;8091:20;;:129;;;;:::i;3747:706:10:-;4166:23;4192:69;4220:4;4192:69;;;;;;;;;;;;;;;;;4200:5;-1:-1:-1;;;;;4192:27:10;;;:69;;;;;:::i;:::-;4275:17;;4166:95;;-1:-1:-1;4275:21:10;4271:176;;4370:10;4359:30;;;;;;;;;;;;:::i;:::-;4351:85;;;;-1:-1:-1;;;4351:85:10;;19127:2:22;4351:85:10;;;19109:21:22;19166:2;19146:18;;;19139:30;19205:34;19185:18;;;19178:62;-1:-1:-1;;;19256:18:22;;;19249:40;19306:19;;4351:85:10;18925:406:22;11198:629:14;11310:7;11329:21;1347:42;-1:-1:-1;;;;;11353:29:14;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11329:55;;11398:13;11415:1;11398:18;11394:68;;11439:12;11432:19;;;;;11394:68;11490:330;1258:2;11698:35;1207:1;1258:2;11698:35;:::i;:::-;11591:37;;-1:-1:-1;;;11591:37:14;;-1:-1:-1;;;;;4675:32:22;;11591:37:14;;;4657:51:22;11656:13:14;;1347:42;;11591:27;;4630:18:22;;11591:37:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3666:12:2;;11575:53:14;;;;:::i;:::-;11574:95;;;;:::i;:::-;11573:161;;;;:::i;:::-;11518:30;1207:1;11518:12;:30;:::i;:::-;11517:218;;;;:::i;:::-;11516:260;;;;:::i;:::-;11794:12;11490:8;:330::i;7148:276::-;-1:-1:-1;;;;;7277:19:14;;;7273:70;;7312:20;7326:5;7312:13;:20::i;:::-;-1:-1:-1;;;;;7356:17:14;;;7352:66;;7389:18;7403:3;7389:13;:18::i;7430:473::-;-1:-1:-1;;;;;7558:19:14;;;7554:172;;7619:24;7637:5;7619:17;:24::i;:::-;-1:-1:-1;;;;;7593:23:14;;;;;;:16;:23;;;;;;;:50;;;7662:53;7593:23;;-1:-1:-1;;;;;;;;;;;7662:53:14;;;529:25:22;;517:2;502:18;;383:177;7662:53:14;;;;;;;;7554:172;-1:-1:-1;;;;;7739:17:14;;;7735:162;;7796:22;7814:3;7796:17;:22::i;:::-;-1:-1:-1;;;;;7772:21:14;;;;;;:16;:21;;;;;;;:46;;;7837:49;7772:21;;-1:-1:-1;;;;;;;;;;;7837:49:14;;;529:25:22;;517:2;502:18;;383:177;7837:49:14;;;;;;;;7430:473;;;:::o;2267:159:2:-;5363:13:1;;;;;;;5355:69;;;;-1:-1:-1;;;5355:69:1;;;;;;;:::i;:::-;2379:5:2::1;:13;2387:5:::0;2379;:13:::1;:::i;:::-;-1:-1:-1::0;2402:7:2::1;:17;2412:7:::0;2402;:17:::1;:::i;9759:659::-:0;-1:-1:-1;;;;;9842:21:2;;9834:67;;;;-1:-1:-1;;;9834:67:2;;21742:2:22;9834:67:2;;;21724:21:22;21781:2;21761:18;;;21754:30;21820:34;21800:18;;;21793:62;-1:-1:-1;;;21871:18:22;;;21864:31;21912:19;;9834:67:2;21540:397:22;9834:67:2;9912:49;9933:7;9950:1;9954:6;9912:20;:49::i;:::-;-1:-1:-1;;;;;9997:18:2;;9972:22;9997:18;;;:9;:18;;;;;;10033:24;;;;10025:71;;;;-1:-1:-1;;;10025:71:2;;22144:2:22;10025:71:2;;;22126:21:22;22183:2;22163:18;;;22156:30;22222:34;22202:18;;;22195:62;-1:-1:-1;;;22273:18:22;;;22266:32;22315:19;;10025:71:2;21942:398:22;10025:71:2;-1:-1:-1;;;;;10130:18:2;;;;;;:9;:18;;;;;;;;10151:23;;;10130:44;;10267:12;:22;;;;;;;10315:37;529:25:22;;;10130:18:2;;;10315:37;;502:18:22;10315:37:2;;;;;;;10363:48;10383:7;10400:1;10404:6;10363:19;:48::i;9446:232:14:-;-1:-1:-1;;;;;9606:32:14;;9508:7;9606:32;;;:22;:32;;;;;;1603:8;;9586:17;:15;:17::i;:::-;:52;;;;:::i;:::-;9547:19;9557:8;9547:9;:19::i;:::-;:92;;;;:::i;19087:180::-;19156:51;;-1:-1:-1;;;19156:51:14;;1512:42;19156:51;;;13283::22;13350:18;;;13343:34;;;464:42:13;;19156:28:14;;13256:18:22;;19156:51:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;19217:43:14;;-1:-1:-1;;;19217:43:14;;;;;529:25:22;;;1512:42:14;;19217:33;;502:18:22;;19217:43:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;974:241:10:-;1139:68;;-1:-1:-1;;;;;22603:15:22;;;1139:68:10;;;22585:34:22;22655:15;;22635:18;;;22628:43;22687:18;;;22680:34;;;1112:96:10;;1132:5;;-1:-1:-1;;;1162:27:10;22520:18:22;;1139:68:10;22345:375:22;8904:535:2;-1:-1:-1;;;;;8987:21:2;;8979:65;;;;-1:-1:-1;;;8979:65:2;;22927:2:22;8979:65:2;;;22909:21:22;22966:2;22946:18;;;22939:30;23005:33;22985:18;;;22978:61;23056:18;;8979:65:2;22725:355:22;8979:65:2;9055:49;9084:1;9088:7;9097:6;9055:20;:49::i;:::-;9131:6;9115:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;9283:18:2;;;;;;:9;:18;;;;;;;;:28;;;;;;9336:37;529:25:22;;;9336:37:2;;502:18:22;9336:37:2;;;;;;;9384:48;9412:1;9416:7;9425:6;9384:19;:48::i;3873:223:11:-;4006:12;4037:52;4059:6;4067:4;4073:1;4076:12;4006;5241;5255:23;5282:6;-1:-1:-1;;;;;5282:11:11;5301:5;5308:4;5282:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5240:73;;;;5330:69;5357:6;5365:7;5374:10;5386:12;5330:26;:69::i;:::-;5323:76;4960:446;-1:-1:-1;;;;;;;4960:446:11:o;7466:628::-;7646:12;7674:7;7670:418;;;7701:10;:17;7722:1;7701:22;7697:286;;-1:-1:-1;;;;;1476:19:5;;;7908:60:11;;;;-1:-1:-1;;;7908:60:11;;23973:2:22;7908:60:11;;;23955:21:22;24012:2;23992:18;;;23985:30;24051:31;24031:18;;;24024:59;24100:18;;7908:60:11;23771:353:22;7908:60:11;-1:-1:-1;8003:10:11;7996:17;;7670:418;8044:33;8052:10;8064:12;8775:17;;:21;8771:379;;9003:10;8997:17;9059:15;9046:10;9042:2;9038:19;9031:44;8771:379;9126:12;9119:20;;-1:-1:-1;;;9119:20:11;;;;;;;;:::i;14:173:22:-;82:20;;-1:-1:-1;;;;;131:31:22;;121:42;;111:70;;177:1;174;167:12;192:186;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;757:258::-;829:1;839:113;853:6;850:1;847:13;839:113;;;929:11;;;923:18;910:11;;;903:39;875:2;868:10;839:113;;;970:6;967:1;964:13;961:48;;;-1:-1:-1;;1005:1:22;987:16;;980:27;757:258::o;1020:383::-;1169:2;1158:9;1151:21;1132:4;1201:6;1195:13;1244:6;1239:2;1228:9;1224:18;1217:34;1260:66;1319:6;1314:2;1303:9;1299:18;1294:2;1286:6;1282:15;1260:66;:::i;:::-;1387:2;1366:15;-1:-1:-1;;1362:29:22;1347:45;;;;1394:2;1343:54;;1020:383;-1:-1:-1;;1020:383:22:o;1408:180::-;1467:6;1520:2;1508:9;1499:7;1495:23;1491:32;1488:52;;;1536:1;1533;1526:12;1488:52;-1:-1:-1;1559:23:22;;1408:180;-1:-1:-1;1408:180:22:o;1593:254::-;1661:6;1669;1722:2;1710:9;1701:7;1697:23;1693:32;1690:52;;;1738:1;1735;1728:12;1690:52;1761:29;1780:9;1761:29;:::i;:::-;1751:39;1837:2;1822:18;;;;1809:32;;-1:-1:-1;;;1593:254:22:o;1852:615::-;1938:6;1946;1999:2;1987:9;1978:7;1974:23;1970:32;1967:52;;;2015:1;2012;2005:12;1967:52;2055:9;2042:23;2084:18;2125:2;2117:6;2114:14;2111:34;;;2141:1;2138;2131:12;2111:34;2179:6;2168:9;2164:22;2154:32;;2224:7;2217:4;2213:2;2209:13;2205:27;2195:55;;2246:1;2243;2236:12;2195:55;2286:2;2273:16;2312:2;2304:6;2301:14;2298:34;;;2328:1;2325;2318:12;2298:34;2381:7;2376:2;2366:6;2363:1;2359:14;2355:2;2351:23;2347:32;2344:45;2341:65;;;2402:1;2399;2392:12;2341:65;2433:2;2425:11;;;;;2455:6;;-1:-1:-1;1852:615:22;;-1:-1:-1;;;;1852:615:22:o;2472:328::-;2549:6;2557;2565;2618:2;2606:9;2597:7;2593:23;2589:32;2586:52;;;2634:1;2631;2624:12;2586:52;2657:29;2676:9;2657:29;:::i;:::-;2647:39;;2705:38;2739:2;2728:9;2724:18;2705:38;:::i;:::-;2695:48;;2790:2;2779:9;2775:18;2762:32;2752:42;;2472:328;;;;;:::o;2805:127::-;2866:10;2861:3;2857:20;2854:1;2847:31;2897:4;2894:1;2887:15;2921:4;2918:1;2911:15;2937:275;3008:2;3002:9;3073:2;3054:13;;-1:-1:-1;;3050:27:22;3038:40;;3108:18;3093:34;;3129:22;;;3090:62;3087:88;;;3155:18;;:::i;:::-;3191:2;3184:22;2937:275;;-1:-1:-1;2937:275:22:o;3217:186::-;3265:4;3298:18;3290:6;3287:30;3284:56;;;3320:18;;:::i;:::-;-1:-1:-1;3386:2:22;3365:15;-1:-1:-1;;3361:29:22;3392:4;3357:40;;3217:186::o;3408:894::-;3503:6;3511;3519;3527;3580:3;3568:9;3559:7;3555:23;3551:33;3548:53;;;3597:1;3594;3587:12;3548:53;3620:29;3639:9;3620:29;:::i;:::-;3610:39;;3668:38;3702:2;3691:9;3687:18;3668:38;:::i;:::-;3658:48;;3725:38;3759:2;3748:9;3744:18;3725:38;:::i;:::-;3715:48;;3814:2;3803:9;3799:18;3786:32;3841:18;3833:6;3830:30;3827:50;;;3873:1;3870;3863:12;3827:50;3896:22;;3949:4;3941:13;;3937:27;-1:-1:-1;3927:55:22;;3978:1;3975;3968:12;3927:55;4014:2;4001:16;4039:48;4055:31;4083:2;4055:31;:::i;:::-;4039:48;:::i;:::-;4110:2;4103:5;4096:17;4150:7;4145:2;4140;4136;4132:11;4128:20;4125:33;4122:53;;;4171:1;4168;4161:12;4122:53;4226:2;4221;4217;4213:11;4208:2;4201:5;4197:14;4184:45;4270:1;4265:2;4260;4253:5;4249:14;4245:23;4238:34;4291:5;4281:15;;;;;3408:894;;;;;;;:::o;4719:254::-;4787:6;4795;4848:2;4836:9;4827:7;4823:23;4819:32;4816:52;;;4864:1;4861;4854:12;4816:52;4900:9;4887:23;4877:33;;4929:38;4963:2;4952:9;4948:18;4929:38;:::i;:::-;4919:48;;4719:254;;;;;:::o;5186:118::-;5272:5;5265:13;5258:21;5251:5;5248:32;5238:60;;5294:1;5291;5284:12;5309:241;5365:6;5418:2;5406:9;5397:7;5393:23;5389:32;5386:52;;;5434:1;5431;5424:12;5386:52;5473:9;5460:23;5492:28;5514:5;5492:28;:::i;5555:328::-;5632:6;5640;5648;5701:2;5689:9;5680:7;5676:23;5672:32;5669:52;;;5717:1;5714;5707:12;5669:52;5753:9;5740:23;5730:33;;5782:38;5816:2;5805:9;5801:18;5782:38;:::i;:::-;5772:48;;5839:38;5873:2;5862:9;5858:18;5839:38;:::i;:::-;5829:48;;5555:328;;;;;:::o;5888:458::-;5971:6;5979;5987;5995;6048:3;6036:9;6027:7;6023:23;6019:33;6016:53;;;6065:1;6062;6055:12;6016:53;6101:9;6088:23;6078:33;;6130:38;6164:2;6153:9;6149:18;6130:38;:::i;:::-;6120:48;;6187:38;6221:2;6210:9;6206:18;6187:38;:::i;:::-;6177:48;;6275:2;6264:9;6260:18;6247:32;6288:28;6310:5;6288:28;:::i;:::-;5888:458;;;;-1:-1:-1;5888:458:22;;-1:-1:-1;;5888:458:22:o;6351:260::-;6419:6;6427;6480:2;6468:9;6459:7;6455:23;6451:32;6448:52;;;6496:1;6493;6486:12;6448:52;6519:29;6538:9;6519:29;:::i;:::-;6509:39;;6567:38;6601:2;6590:9;6586:18;6567:38;:::i;6849:127::-;6910:10;6905:3;6901:20;6898:1;6891:31;6941:4;6938:1;6931:15;6965:4;6962:1;6955:15;6981:128;7021:3;7052:1;7048:6;7045:1;7042:13;7039:39;;;7058:18;;:::i;:::-;-1:-1:-1;7094:9:22;;6981:128::o;7458:184::-;7528:6;7581:2;7569:9;7560:7;7556:23;7552:32;7549:52;;;7597:1;7594;7587:12;7549:52;-1:-1:-1;7620:16:22;;7458:184;-1:-1:-1;7458:184:22:o;7647:380::-;7726:1;7722:12;;;;7769;;;7790:61;;7844:4;7836:6;7832:17;7822:27;;7790:61;7897:2;7889:6;7886:14;7866:18;7863:38;7860:161;;7943:10;7938:3;7934:20;7931:1;7924:31;7978:4;7975:1;7968:15;8006:4;8003:1;7996:15;8032:127;8093:10;8088:3;8084:20;8081:1;8074:31;8124:4;8121:1;8114:15;8148:4;8145:1;8138:15;8164:135;8203:3;8224:17;;;8221:43;;8244:18;;:::i;:::-;-1:-1:-1;8291:1:22;8280:13;;8164:135::o;9071:635::-;9151:6;9204:2;9192:9;9183:7;9179:23;9175:32;9172:52;;;9220:1;9217;9210:12;9172:52;9253:9;9247:16;9286:18;9278:6;9275:30;9272:50;;;9318:1;9315;9308:12;9272:50;9341:22;;9394:4;9386:13;;9382:27;-1:-1:-1;9372:55:22;;9423:1;9420;9413:12;9372:55;9452:2;9446:9;9477:48;9493:31;9521:2;9493:31;:::i;9477:48::-;9548:2;9541:5;9534:17;9588:7;9583:2;9578;9574;9570:11;9566:20;9563:33;9560:53;;;9609:1;9606;9599:12;9560:53;9622:54;9673:2;9668;9661:5;9657:14;9652:2;9648;9644:11;9622:54;:::i;9711:413::-;-1:-1:-1;;;9957:3:22;9950:22;9932:3;10001:6;9995:13;10017:61;10071:6;10067:1;10062:3;10058:11;10051:4;10043:6;10039:17;10017:61;:::i;:::-;10098:16;;;;10116:1;10094:24;;9711:413;-1:-1:-1;;9711:413:22:o;10129:409::-;-1:-1:-1;;;10375:3:22;10368:18;10350:3;10415:6;10409:13;10431:61;10485:6;10481:1;10476:3;10472:11;10465:4;10457:6;10453:17;10431:61;:::i;:::-;10512:16;;;;10530:1;10508:24;;10129:409;-1:-1:-1;;10129:409:22:o;12223:125::-;12263:4;12291:1;12288;12285:8;12282:34;;;12296:18;;:::i;:::-;-1:-1:-1;12333:9:22;;12223:125::o;12353:168::-;12393:7;12459:1;12455;12451:6;12447:14;12444:1;12441:21;12436:1;12429:9;12422:17;12418:45;12415:71;;;12466:18;;:::i;:::-;-1:-1:-1;12506:9:22;;12353:168::o;12526:217::-;12566:1;12592;12582:132;;12636:10;12631:3;12627:20;12624:1;12617:31;12671:4;12668:1;12661:15;12699:4;12696:1;12689:15;12582:132;-1:-1:-1;12728:9:22;;12526:217::o;16118:407::-;16320:2;16302:21;;;16359:2;16339:18;;;16332:30;16398:34;16393:2;16378:18;;16371:62;-1:-1:-1;;;16464:2:22;16449:18;;16442:41;16515:3;16500:19;;16118:407::o;17142:306::-;17230:6;17238;17246;17299:2;17287:9;17278:7;17274:23;17270:32;17267:52;;;17315:1;17312;17305:12;17267:52;17344:9;17338:16;17328:26;;17394:2;17383:9;17379:18;17373:25;17363:35;;17438:2;17427:9;17423:18;17417:25;17407:35;;17142:306;;;;;:::o;18675:245::-;18742:6;18795:2;18783:9;18774:7;18770:23;18766:32;18763:52;;;18811:1;18808;18801:12;18763:52;18843:9;18837:16;18862:28;18884:5;18862:28;:::i;19462:545::-;19564:2;19559:3;19556:11;19553:448;;;19600:1;19625:5;19621:2;19614:17;19670:4;19666:2;19656:19;19740:2;19728:10;19724:19;19721:1;19717:27;19711:4;19707:38;19776:4;19764:10;19761:20;19758:47;;;-1:-1:-1;19799:4:22;19758:47;19854:2;19849:3;19845:12;19842:1;19838:20;19832:4;19828:31;19818:41;;19909:82;19927:2;19920:5;19917:13;19909:82;;;19972:17;;;19953:1;19942:13;19909:82;;;19913:3;;;19462:545;;;:::o;20183:1352::-;20309:3;20303:10;20336:18;20328:6;20325:30;20322:56;;;20358:18;;:::i;:::-;20387:97;20477:6;20437:38;20469:4;20463:11;20437:38;:::i;:::-;20431:4;20387:97;:::i;:::-;20539:4;;20603:2;20592:14;;20620:1;20615:663;;;;21322:1;21339:6;21336:89;;;-1:-1:-1;21391:19:22;;;21385:26;21336:89;-1:-1:-1;;20140:1:22;20136:11;;;20132:24;20128:29;20118:40;20164:1;20160:11;;;20115:57;21438:81;;20585:944;;20615:663;19409:1;19402:14;;;19446:4;19433:18;;-1:-1:-1;;20651:20:22;;;20769:236;20783:7;20780:1;20777:14;20769:236;;;20872:19;;;20866:26;20851:42;;20964:27;;;;20932:1;20920:14;;;;20799:19;;20769:236;;;20773:3;21033:6;21024:7;21021:19;21018:201;;;21094:19;;;21088:26;-1:-1:-1;;21177:1:22;21173:14;;;21189:3;21169:24;21165:37;21161:42;21146:58;21131:74;;21018:201;-1:-1:-1;;;;;21265:1:22;21249:14;;;21245:22;21232:36;;-1:-1:-1;20183:1352:22:o;23492:274::-;23621:3;23659:6;23653:13;23675:53;23721:6;23716:3;23709:4;23701:6;23697:17;23675:53;:::i;:::-;23744:16;;;;;23492:274;-1:-1:-1;;23492:274:22:o

ipfs://f9091adf8108da5282e345476b130fe277f3ce5cba9299502e87eb94e2bf5496