Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at moonriver.moonscan.io on 2022-04-17
*/

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

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

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

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

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

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

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

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

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

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

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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

    /**
     * @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"
            );
        }
    }
}

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

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

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

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

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

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

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

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

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

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

// File: node_modules\@uniswap\v2-periphery\contracts\interfaces\IUniswapV2Router01.sol

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

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

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

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

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

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountETH);

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

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

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

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

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

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

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

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

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

// File: @uniswap\v2-periphery\contracts\interfaces\IUniswapV2Router02.sol

pragma solidity >=0.6.2;

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

/**
 * @dev Vesting contract interface
 */
interface IRovrVesting {
    /**
     * @notice Vest tokens for the account
     */
    function vestTokens(address account_, uint256 amount_) external;

    /**
     * @notice Claim available tokens
     */
    function claimTokens() external;

    /**
     * @notice View user vesting info
     */
    function userVestingInfo(address account_)
        external
        view
        returns (
            uint256,
            uint256,
            uint256
        );
}

contract RovrVault is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 rewardLockedUp; // Reward locked up.
        uint256 nextHarvestUntil; // When can the user harvest again.
        uint256 lastInteraction; // Last time when user deposited or claimed rewards, renewing the lock
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken; // Address of LP token contract
        uint256 allocPoint; // How many allocation points assigned to this pool. Rovr to distribute per block.
        uint256 lastRewardBlock; // Last block number that Rovr distribution occurs.
        uint256 accRovrPerShare; // Accumulated Rovr per share, times 1e12. See below.
        uint16 depositFeeBP; // Deposit fee in basis points
        uint256 harvestInterval; // Harvest interval in seconds
        uint256 totalLp; // Total token in Pool
        uint256 lockupDuration; // Amount of time the participant will be locked in the pool after depositing or claiming rewards
    }

    IERC20 public immutable rovr;
    IRovrVesting public immutable vestingContract;
    IUniswapV2Router02 public swapRouter;
    address public farmAddress;

    // Deposit Fee address
    address public feeAddress;

    address private BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;

    // Rovr tokens created per block
    uint256 public rovrPerBlock;

    // Max harvest interval: 14 days
    uint256 public constant MAXIMUM_HARVEST_INTERVAL = 14 days;

    // Maximum deposit fee rate: 10%
    uint16 public constant MAXIMUM_DEPOSIT_FEE_RATE = 1000;

    // Direct harvest rate: 10%
    uint16 public directHarvestRate = 1000;

    uint16 public liquifyRate = 5000; // 50% is added to liquidity
    uint16 public burnRate = 2500; // 25% is burned
    uint16 public farmRewardRate = 2500; // 25% is sent to yield-farm rewards

    // Info of each pool
    PoolInfo[] public poolInfo;

    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;

    // The block number when Rovr mining starts.
    uint256 public startBlock;

    // Total locked up rewards
    uint256 public totalLockedUpRewards;

    // Total Rovr in Rovr Pools (can be multiple pools)
    uint256 public totalRovrInPools = 0;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(
        address indexed user,
        uint256 indexed pid,
        uint256 amount
    );
    event EmissionRateUpdated(
        address indexed caller,
        uint256 previousAmount,
        uint256 newAmount
    );
    event RewardLockedUp(
        address indexed user,
        uint256 indexed pid,
        uint256 amountLockedUp
    );
    event FeeAddressChanged(
        address indexed caller,
        address oldAddress,
        address newAddress
    );

    constructor(
        IERC20 _rovr,
        IRovrVesting _vesting,
        uint256 _rovrPerBlock
    ) {
        //StartBlock always many years later from contract construct, will be set later in StartFarming function
        startBlock = block.number.add(3650 days);

        rovr = _rovr;
        vestingContract = _vesting;
        rovrPerBlock = _rovrPerBlock;

        feeAddress = msg.sender;
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to)
        public
        pure
        returns (uint256)
    {
        return _to.sub(_from);
    }

    // Set farming start, can call only once
    function startFarming() public onlyOwner {
        require(block.number < startBlock, "Error: farm started already");

        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            PoolInfo storage pool = poolInfo[pid];
            pool.lastRewardBlock = block.number;
        }

        startBlock = block.number;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    // Can add multiple pool with same lp token without messing up rewards, because each pool's balance is tracked using its own totalLp
    function add(
        uint256 _allocPoint,
        IERC20 _lpToken,
        uint16 _depositFeeBP,
        uint256 _harvestInterval,
        uint256 _lockupDuration,
        bool _withUpdate
    ) external onlyOwner {
        require(
            _depositFeeBP <= MAXIMUM_DEPOSIT_FEE_RATE,
            "Add: deposit fee too high"
        );
        require(
            _harvestInterval <= MAXIMUM_HARVEST_INTERVAL,
            "Add: invalid harvest interval"
        );
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock
            ? block.number
            : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                allocPoint: _allocPoint,
                lastRewardBlock: lastRewardBlock,
                accRovrPerShare: 0,
                depositFeeBP: _depositFeeBP,
                harvestInterval: _harvestInterval,
                totalLp: 0,
                lockupDuration: _lockupDuration
            })
        );
    }

    function updateAllocPoint(
        uint256 _pid,
        uint256 _allocPoint,
        uint16 _depositFeeBP,
        uint256 _harvestInterval,
        uint256 _lockupDuration,
        bool _withUpdate
    ) external onlyOwner {
        require(
            _depositFeeBP <= MAXIMUM_DEPOSIT_FEE_RATE,
            "Add: deposit fee too high"
        );
        require(
            _harvestInterval <= MAXIMUM_HARVEST_INTERVAL,
            "Add: invalid harvest interval"
        );
        if (_withUpdate) {
            massUpdatePools();
        }

        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(
            _allocPoint
        );
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
        poolInfo[_pid].harvestInterval = _harvestInterval;
        poolInfo[_pid].lockupDuration = _lockupDuration;
    }

    // View function to see pending Rovr on frontend.
    function pendingRovr(uint256 _pid, address _user)
        external
        view
        returns (uint256)
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accRovrPerShare = pool.accRovrPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));

        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(
                pool.lastRewardBlock,
                block.number
            );
            uint256 rovrReward = multiplier
                .mul(rovrPerBlock)
                .mul(pool.allocPoint)
                .div(totalAllocPoint);
            accRovrPerShare = accRovrPerShare.add(
                rovrReward.mul(1e12).div(lpSupply)
            );
        }

        uint256 pending = user.amount.mul(accRovrPerShare).div(1e12).sub(
            user.rewardDebt
        );
        return pending.add(user.rewardLockedUp);
    }

    // View function to see when user will be unlocked from pool
    function userLockedUntil(uint256 _pid, address _user)
        external
        view
        returns (uint256)
    {
        UserInfo storage user = userInfo[_pid][_user];
        PoolInfo storage pool = poolInfo[_pid];

        return user.lastInteraction.add(pool.lockupDuration);
    }

    // View function to see if user can harvest Rovr.
    function canHarvest(uint256 _pid, address _user)
        public
        view
        returns (bool)
    {
        UserInfo storage user = userInfo[_pid][_user];
        return
            block.number >= startBlock &&
            block.timestamp >= user.nextHarvestUntil;
    }

    // Update reward vairables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }

        uint256 lpSupply = pool.totalLp;
        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }

        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 rovrReward = multiplier
            .mul(rovrPerBlock)
            .mul(pool.allocPoint)
            .div(totalAllocPoint);

        pool.accRovrPerShare = pool.accRovrPerShare.add(
            rovrReward.mul(1e12).div(pool.totalLp)
        );
        pool.lastRewardBlock = block.number;
    }

    /**
     * @notice Handle fee
     */
    function handleFee(uint256 _pid, uint256 _feeAmount) private {
        PoolInfo memory pool = poolInfo[_pid];
        // Burn 25%
        uint256 burnAmount = _feeAmount.mul(burnRate).div(10000);
        if (burnAmount > 0) {
            pool.lpToken.safeTransfer(BURN_ADDRESS, burnAmount);
        }
        // Send 25% to yield-farm rewards
        uint256 farmRewardAmount = _feeAmount.mul(farmRewardRate).div(10000);
        if (farmRewardAmount > 0 && farmAddress != address(0)) {
            pool.lpToken.safeTransfer(farmAddress, farmRewardAmount);
        }
        // 50% to liquidity pool
        uint256 liquifyAmount = _feeAmount.sub(burnAmount).sub(
            farmRewardAmount
        );
        if (address(swapRouter) != address(0) && liquifyAmount > 0) {
            uint256 toSwapAmount = liquifyAmount.div(2);
            uint256 toLPAmount = liquifyAmount.sub(toSwapAmount);
            // Swap tokens to eth first
            (uint256 swappedEthAmount, bool success) = swapTokenToETH(
                address(pool.lpToken),
                toSwapAmount,
                payable(address(this))
            );
            // Add liquidity with swapped ETH and remained tokens
            if (success && swappedEthAmount > 0) {
                addLiquidityETH(
                    address(pool.lpToken),
                    toLPAmount,
                    swappedEthAmount,
                    feeAddress
                );
            }
        }
    }

    /**
     * @notice Swap tokens to ETH
     */
    function swapTokenToETH(
        address _token,
        uint256 _tokenAmount,
        address payable _to
    ) private returns (uint256 ethAmount, bool success) {
        // approve token transfer to cover all possible scenarios
        IERC20(_token).approve(address(swapRouter), _tokenAmount);
        
        // generate the saunaSwap pair path of bnb -> web3
        address[] memory path = new address[](2);
        path[0] = _token;
        path[1] = swapRouter.WETH();

        // make the swap
        uint256 balanceBefore = _to.balance;
        try
            swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
                _tokenAmount,
                0, // accept any amount of ETH
                path,
                _to,
                block.timestamp.add(300)
            )
        {
            ethAmount = _to.balance.sub(balanceBefore);
            success = true;
        } catch (
            bytes memory /* lowLevelData */
        ) {
            success = false;
            ethAmount = 0;
        }
    }

    /**
     * @notice Add liquidity
     */
    function addLiquidityETH(
        address _token,
        uint256 _tokenAmount,
        uint256 _ethAmount,
        address _to
    ) private returns (bool success) {
        // approve token transfer to cover all possible scenarios
        IERC20(_token).approve(address(swapRouter), _tokenAmount);

        // add the liquidity
        try
            swapRouter.addLiquidityETH{value: _ethAmount}(
                _token,
                _tokenAmount,
                0, // slippage is unavoidable
                0, // slippage is unavoidable
                _to,
                block.timestamp.add(300)
            )
        {
            success = true;
        } catch (
            bytes memory /* lowLevelData */
        ) {
            success = false;
        }
    }

    // Deposit LP tokens to RovrVault for Rovr allocation
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {
        require(
            block.number >= startBlock,
            "RovrVault: cannot deposit before farming start"
        );

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

        updatePool(_pid);
        payOrLockupPendingRovr(_pid);

        if (_amount > 0) {
            uint256 beforeDeposit = pool.lpToken.balanceOf(address(this));
            pool.lpToken.safeTransferFrom(_msgSender(), address(this), _amount);
            uint256 afterDeposit = pool.lpToken.balanceOf(address(this));

            _amount = afterDeposit.sub(beforeDeposit);

            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                if (depositFee > 0) {
                    handleFee(_pid, depositFee);
                    _amount = _amount.sub(depositFee);
                }
            }

            user.amount = user.amount.add(_amount);
            pool.totalLp = pool.totalLp.add(_amount);

            if (address(pool.lpToken) == address(rovr)) {
                totalRovrInPools = totalRovrInPools.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accRovrPerShare).div(1e12);
        user.lastInteraction = block.timestamp;
        emit Deposit(_msgSender(), _pid, _amount);
    }

    // Withdraw tokens
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

        //this will make sure that user can only withdraw from his pool
        require(user.amount >= _amount, "Withdraw: user amount is not enough");

        //Cannot withdraw more than pool's balance
        require(pool.totalLp >= _amount, "Withdraw: pool total is not enough");

        //Cannot withdraw before lock time
        require(
            block.timestamp > user.lastInteraction.add(pool.lockupDuration),
            "Withdraw: you cannot withdraw yet"
        );

        updatePool(_pid);
        payOrLockupPendingRovr(_pid);

        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.totalLp = pool.totalLp.sub(_amount);
            if (address(pool.lpToken) == address(rovr)) {
                totalRovrInPools = totalRovrInPools.sub(_amount);
            }
            pool.lpToken.safeTransfer(_msgSender(), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accRovrPerShare).div(1e12);
        user.lastInteraction = block.timestamp;
        emit Withdraw(_msgSender(), _pid, _amount);
    }

    // Pay or lockup pending Rovr.
    function payOrLockupPendingRovr(uint256 _pid) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

        if (user.nextHarvestUntil == 0 && block.number >= startBlock) {
            user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);
        }

        uint256 pending = user.amount.mul(pool.accRovrPerShare).div(1e12).sub(
            user.rewardDebt
        );
        if (canHarvest(_pid, _msgSender())) {
            if (pending > 0 || user.rewardLockedUp > 0) {
                uint256 totalRewards = pending.add(user.rewardLockedUp);
                // send rewards
                uint256 rewardsTransferred = safeRovrTransfer(
                    _msgSender(),
                    totalRewards
                );
                uint256 rewardsUnTransferred = totalRewards.sub(
                    rewardsTransferred
                );

                // reset lockup
                totalLockedUpRewards = totalLockedUpRewards
                    .sub(user.rewardLockedUp)
                    .add(rewardsUnTransferred);
                user.rewardLockedUp = rewardsUnTransferred;
                user.nextHarvestUntil = block.timestamp.add(
                    pool.harvestInterval
                );
            }
        } else if (pending > 0) {
            user.rewardLockedUp = user.rewardLockedUp.add(pending);
            totalLockedUpRewards = totalLockedUpRewards.add(pending);
            emit RewardLockedUp(_msgSender(), _pid, pending);
        }
    }

    // Safe Rovr transfer function, just in case if rounding error causes pool do not have enough Rovr.
    function safeRovrTransfer(address _to, uint256 _amount)
        private
        returns (uint256)
    {
        if (_amount > 0 && rovr.balanceOf(address(this)) > totalRovrInPools) {
            //RovrBal = total Rovr in RovrVault - total Rovr in Rovr pools, this will make sure that RovrVault never transfer rewards from deposited Rovr pools
            uint256 rovrBal = rovr.balanceOf(address(this)).sub(
                totalRovrInPools
            );
            if (_amount >= rovrBal) {
                _amount = rovrBal;
            }

            // 10% is harvested directly to the user
            uint256 directHarvestAmount = _amount.mul(directHarvestRate).div(
                10000
            );
            if (directHarvestAmount > 0) {
                rovr.safeTransfer(_to, directHarvestAmount);
            }
            // 90% is vested for 90 days
            if (_amount > directHarvestAmount) {
                rovr.approve(
                    address(vestingContract),
                    _amount.sub(directHarvestAmount)
                );
                vestingContract.vestTokens(
                    _to,
                    _amount.sub(directHarvestAmount)
                );
            }

            return _amount;
        }
        return 0;
    }

    function setSwapRouter(address _swapRouter) external onlyOwner {
        require(_swapRouter != address(0), "Invalid swap router");
        swapRouter = IUniswapV2Router02(_swapRouter);
    }

    function setFarmAddress(address _farmAddress) external onlyOwner {
        require(_farmAddress != address(0), "Invalid farm address");
        farmAddress = _farmAddress;
    }

    function setFeeAllocRates(
        uint16 _liquifyRate,
        uint16 _burnRate,
        uint16 _farmRewardRate
    ) external onlyOwner {
        require(
            _liquifyRate + _burnRate + _farmRewardRate == 10000,
            "Invalid rates"
        );
        liquifyRate = _liquifyRate;
        burnRate = _burnRate;
        farmRewardRate = _farmRewardRate;
    }

    function setDirectHarvestRate(uint16 _rate) external onlyOwner {
        require(_rate <= 10000, "Invalid rate value");
        directHarvestRate = _rate;
    }

    function setFeeAddress(address _feeAddress) external {
        require(_msgSender() == feeAddress, "setFeeAddress: FORBIDDEN");
        require(_feeAddress != address(0), "setFeeAddress: ZERO");

        emit FeeAddressChanged(_msgSender(), feeAddress, _feeAddress);

        feeAddress = _feeAddress;
    }

    function updateEmissionRate(uint256 _rovrPerBlock) external onlyOwner {
        massUpdatePools();

        emit EmissionRateUpdated(msg.sender, rovrPerBlock, _rovrPerBlock);
        rovrPerBlock = _rovrPerBlock;
    }

    // to recieve ETH
    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_rovr","type":"address"},{"internalType":"contract IRovrVesting","name":"_vesting","type":"address"},{"internalType":"uint256","name":"_rovrPerBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"EmissionRateUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":false,"internalType":"address","name":"newAddress","type":"address"}],"name":"FeeAddressChanged","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":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountLockedUp","type":"uint256"}],"name":"RewardLockedUp","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MAXIMUM_DEPOSIT_FEE_RATE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_HARVEST_INTERVAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"uint256","name":"_lockupDuration","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burnRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"canHarvest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"directHarvestRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"farmAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"farmRewardRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"liquifyRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingRovr","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accRovrPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"harvestInterval","type":"uint256"},{"internalType":"uint256","name":"totalLp","type":"uint256"},{"internalType":"uint256","name":"lockupDuration","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rovr","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rovrPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"_rate","type":"uint16"}],"name":"setDirectHarvestRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_farmAddress","type":"address"}],"name":"setFarmAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_liquifyRate","type":"uint16"},{"internalType":"uint16","name":"_burnRate","type":"uint16"},{"internalType":"uint16","name":"_farmRewardRate","type":"uint16"}],"name":"setFeeAllocRates","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_swapRouter","type":"address"}],"name":"setSwapRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startFarming","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapRouter","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLockedUpRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRovrInPools","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"uint256","name":"_lockupDuration","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"updateAllocPoint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rovrPerBlock","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"rewardLockedUp","type":"uint256"},{"internalType":"uint256","name":"nextHarvestUntil","type":"uint256"},{"internalType":"uint256","name":"lastInteraction","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"userLockedUntil","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingContract","outputs":[{"internalType":"contract IRovrVesting","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000009abbe055b25247a7336d9dc7b751c84e0a68fb000000000000000000000000001a2af1cfe9c025165674f5aeb26d766e3cd62e3900000000000000000000000000000000000000000000014542ba12a337c00000

-----Decoded View---------------
Arg [0] : _rovr (address): 0x9AbbE055b25247a7336d9Dc7b751C84e0A68Fb00
Arg [1] : _vesting (address): 0x1a2af1cfE9c025165674f5aEb26D766e3cd62E39
Arg [2] : _rovrPerBlock (uint256): 6000000000000000000000

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000009abbe055b25247a7336d9dc7b751c84e0a68fb00
Arg [1] : 0000000000000000000000001a2af1cfe9c025165674f5aeb26d766e3cd62e39
Arg [2] : 00000000000000000000000000000000000000000000014542ba12a337c00000

34509:20787:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38967:95;;;;;;;;;;-1:-1:-1;39039:8:0;:15;38967:95;;;15476:25:1;;;15464:2;15449:18;38967:95:0;;;;;;;;55010:223;;;;;;;;;;-1:-1:-1;55010:223:0;;;;;:::i;:::-;;:::i;:::-;;36113:27;;;;;;;;;;;;;;;;36663:26;;;;;;;;;;-1:-1:-1;36663:26:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;6840:32:1;;;6822:51;;6904:2;6889:18;;6882:34;;;;6932:18;;;6925:34;;;;6990:2;6975:18;;6968:34;;;;7051:6;7039:19;7033:3;7018:19;;7011:48;6860:3;7075:19;;7068:35;7134:3;7119:19;;7112:35;7178:3;7163:19;;7156:35;6809:3;6794:19;36663:26:0;6468:729:1;36908:34:0;;;;;;;;;;;;;;;;54517:163;;;;;;;;;;-1:-1:-1;54517:163:0;;;;;:::i;:::-;;:::i;42863:286::-;;;;;;;;;;-1:-1:-1;42863:286:0;;;;;:::i;:::-;;:::i;:::-;;;6220:14:1;;6213:22;6195:41;;6183:2;6168:18;42863:286:0;6055:187:1;39275:1157:0;;;;;;;;;;-1:-1:-1;39275:1157:0;;;;;:::i;:::-;;:::i;41415:1015::-;;;;;;;;;;-1:-1:-1;41415:1015:0;;;;;:::i;:::-;;:::i;53733:194::-;;;;;;;;;;-1:-1:-1;53733:194:0;;;;;:::i;:::-;;:::i;35959:25::-;;;;;;;;;;-1:-1:-1;35959:25:0;;;;-1:-1:-1;;;;;35959:25:0;;;;;;-1:-1:-1;;;;;4431:32:1;;;4413:51;;4401:2;4386:18;35959:25:0;4267:203:1;49369:1282:0;;;;;;;;;;-1:-1:-1;49369:1282:0;;;;;:::i;:::-;;:::i;36556:35::-;;;;;;;;;;-1:-1:-1;36556:35:0;;;;-1:-1:-1;;;36556:35:0;;;;;;;;;15311:6:1;15299:19;;;15281:38;;15269:2;15254:18;36556:35:0;15137:188:1;37067:35:0;;;;;;;;;;;;;;;;37001:25;;;;;;;;;;;;;;;;43488:760;;;;;;;;;;-1:-1:-1;43488:760:0;;;;;:::i;:::-;;:::i;35801:45::-;;;;;;;;;;;;;;;43232:180;;;;;;;;;;;;;:::i;40440:912::-;;;;;;;;;;-1:-1:-1;40440:912:0;;;;;:::i;:::-;;:::i;36388:38::-;;;;;;;;;;-1:-1:-1;36388:38:0;;;;;;;;17789:94;;;;;;;;;;;;;:::i;36292:54::-;;;;;;;;;;;;36342:4;36292:54;;54688:314;;;;;;;;;;-1:-1:-1;54688:314:0;;;;;:::i;:::-;;:::i;37168:35::-;;;;;;;;;;;;;;;;17138:87;;;;;;;;;;-1:-1:-1;17184:7:0;17211:6;-1:-1:-1;;;;;17211:6:0;17138:87;;38377:153;;;;;;;;;;-1:-1:-1;38377:153:0;;;;;:::i;:::-;;:::i;36747:64::-;;;;;;;;;;-1:-1:-1;36747:64:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17017:25:1;;;17073:2;17058:18;;17051:34;;;;17101:18;;;17094:34;;;;17159:2;17144:18;;17137:34;17202:3;17187:19;;17180:35;17004:3;16989:19;36747:64:0;16758:463:1;38584:375:0;;;;;;;;;;;;;:::i;35766:28::-;;;;;;;;;;;;;;;36503:29;;;;;;;;;;-1:-1:-1;36503:29:0;;;;;;;;;;;36435:32;;;;;;;;;;-1:-1:-1;36435:32:0;;;;;;;;;;;35853:36;;;;;;;;;;-1:-1:-1;35853:36:0;;;;-1:-1:-1;;;;;35853:36:0;;;42504:296;;;;;;;;;;-1:-1:-1;42504:296:0;;;;;:::i;:::-;;:::i;53935:180::-;;;;;;;;;;-1:-1:-1;53935:180:0;;;;;:::i;:::-;;:::i;36187:58::-;;;;;;;;;;;;36238:7;36187:58;;47880:1457;;;;;;;;;;-1:-1:-1;47880:1457:0;;;;;:::i;:::-;;:::i;18038:229::-;;;;;;;;;;-1:-1:-1;18038:229:0;;;;;:::i;:::-;;:::i;54123:386::-;;;;;;;;;;-1:-1:-1;54123:386:0;;;;;:::i;:::-;;:::i;35896:26::-;;;;;;;;;;-1:-1:-1;35896:26:0;;;;-1:-1:-1;;;;;35896:26:0;;;55010:223;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;;;;;;;;;55091:17:::1;:15;:17::i;:::-;55158:12;::::0;55126:60:::1;::::0;;16679:25:1;;;16735:2;16720:18;;16713:34;;;55146:10:0::1;::::0;55126:60:::1;::::0;16652:18:1;55126:60:0::1;;;;;;;55197:12;:28:::0;55010:223::o;36663:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36663:26:0;;;;-1:-1:-1;36663:26:0;;;;;;;;;;;;;;:::o;54517:163::-;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;54608:5:::1;54599;:14;;;;54591:45;;;::::0;-1:-1:-1;;;54591:45:0;;14992:2:1;54591:45:0::1;::::0;::::1;14974:21:1::0;15031:2;15011:18;;;15004:30;-1:-1:-1;;;15050:18:1;;;15043:48;15108:18;;54591:45:0::1;14790:342:1::0;54591:45:0::1;54647:17;:25:::0;;-1:-1:-1;;54647:25:0::1;;::::0;;;::::1;::::0;;;::::1;::::0;;54517:163::o;42863:286::-;42960:4;43006:14;;;:8;:14;;;;;;;;-1:-1:-1;;;;;43006:21:0;;;;;;;;;43074:10;;43058:12;:26;;;;:83;;;43120:4;:21;;;43101:15;:40;;43058:83;43038:103;;;42863:286;;;;;:::o;39275:1157::-;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;36342:4:::1;39530:41;::::0;::::1;;;39508:116;;;::::0;-1:-1:-1;;;39508:116:0;;9008:2:1;39508:116:0::1;::::0;::::1;8990:21:1::0;9047:2;9027:18;;;9020:30;-1:-1:-1;;;9066:18:1;;;9059:55;9131:18;;39508:116:0::1;8806:349:1::0;39508:116:0::1;36238:7;39657:16;:44;;39635:123;;;::::0;-1:-1:-1;;;39635:123:0;;13152:2:1;39635:123:0::1;::::0;::::1;13134:21:1::0;13191:2;13171:18;;;13164:30;13230:31;13210:18;;;13203:59;13279:18;;39635:123:0::1;12950:353:1::0;39635:123:0::1;39773:11;39769:61;;;39801:17;:15;:17::i;:::-;39840:23;39881:10;;39866:12;:25;:79;;39935:10;;39866:79;;;39907:12;39866:79;39974:15;::::0;39840:105;;-1:-1:-1;39974:32:0::1;::::0;39994:11;39974:19:::1;:32::i;:::-;39956:15;:50:::0;40045:368:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;40045:368:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;40045:368:0;;;;;;::::1;::::0;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;40017:8:::1;:407:::0;;::::1;::::0;::::1;::::0;;;;;;;;;;;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;40017:407:0::1;::::0;;;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;40017:407:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;-1:-1:-1;40017:407:0;;;;;;;39275:1157::o;41415:1015::-;41515:7;41540:21;41564:8;41573:4;41564:14;;;;;;;;:::i;:::-;;;;;;;;;41613;;;:8;:14;;;;;;-1:-1:-1;;;;;41613:21:0;;;;;;;;;;41564:14;;;;;;;;41671:20;;;;41721:12;;:37;;-1:-1:-1;;;41721:37:0;;41752:4;41721:37;;;4413:51:1;41564:14:0;;-1:-1:-1;41613:21:0;;41564:14;41721:12;;;;;:22;;4386:18:1;;41721:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41702:56;;41790:4;:20;;;41775:12;:35;:52;;;;-1:-1:-1;41814:13:0;;;41775:52;41771:484;;;41844:18;41865:98;41897:4;:20;;;41936:12;41865:13;:98::i;:::-;41844:119;;41978:18;41999:124;42107:15;;41999:85;42068:4;:15;;;41999:46;42032:12;;41999:10;:32;;:46;;;;:::i;:::-;:68;;:85::i;:::-;:107;;:124::i;:::-;41978:145;-1:-1:-1;42156:87:0;42194:34;42219:8;42194:20;41978:145;42209:4;42194:14;:20::i;:34::-;42156:15;;:19;:87::i;:::-;42138:105;;41829:426;;41771:484;42267:15;42285:87;42346:4;:15;;;42285:42;42322:4;42285:32;42301:15;42285:4;:11;;;:15;;:32;;;;:::i;:42::-;:46;;:87::i;:::-;42267:105;;42390:32;42402:4;:19;;;42390:7;:11;;:32;;;;:::i;:::-;42383:39;41415:1015;-1:-1:-1;;;;;;;;41415:1015:0:o;53733:194::-;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;53815:25:0;::::1;53807:57;;;::::0;-1:-1:-1;;;53807:57:0;;12400:2:1;53807:57:0::1;::::0;::::1;12382:21:1::0;12439:2;12419:18;;;12412:30;-1:-1:-1;;;12458:18:1;;;12451:49;12517:18;;53807:57:0::1;12198:343:1::0;53807:57:0::1;53875:10;:44:::0;;-1:-1:-1;;;;;;53875:44:0::1;-1:-1:-1::0;;;;;53875:44:0;;;::::1;::::0;;;::::1;::::0;;53733:194::o;49369:1282::-;20106:1;20702:7;;:19;;20694:63;;;;-1:-1:-1;;;20694:63:0;;14632:2:1;20694:63:0;;;14614:21:1;14671:2;14651:18;;;14644:30;14710:33;14690:18;;;14683:61;14761:18;;20694:63:0;14430:355:1;20694:63:0;20106:1;20835:7;:18;;;;49449:21:::1;49473:8;49482:4;49473:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;49522;;;:8:::1;:14:::0;;;;;;49473::::1;::::0;;::::1;;::::0;-1:-1:-1;49473:14:0;49537:12:::1;16069:10:::0;;15989:98;49537:12:::1;-1:-1:-1::0;;;;;49522:28:0::1;-1:-1:-1::0;;;;;49522:28:0::1;;;;;;;;;;;;49498:52;;49659:7;49644:4;:11;;;:22;;49636:70;;;::::0;-1:-1:-1;;;49636:70:0;;12748:2:1;49636:70:0::1;::::0;::::1;12730:21:1::0;12787:2;12767:18;;;12760:30;12826:34;12806:18;;;12799:62;-1:-1:-1;;;12877:18:1;;;12870:33;12920:19;;49636:70:0::1;12546:399:1::0;49636:70:0::1;49795:7;49779:4;:12;;;:23;;49771:70;;;::::0;-1:-1:-1;;;49771:70:0;;8605:2:1;49771:70:0::1;::::0;::::1;8587:21:1::0;8644:2;8624:18;;;8617:30;8683:34;8663:18;;;8656:62;-1:-1:-1;;;8734:18:1;;;8727:32;8776:19;;49771:70:0::1;8403:398:1::0;49771:70:0::1;49963:19;::::0;::::1;::::0;49938:20:::1;::::0;::::1;::::0;:45:::1;::::0;:24:::1;:45::i;:::-;49920:15;:63;49898:146;;;::::0;-1:-1:-1;;;49898:146:0;;10117:2:1;49898:146:0::1;::::0;::::1;10099:21:1::0;10156:2;10136:18;;;10129:30;10195:34;10175:18;;;10168:62;-1:-1:-1;;;10246:18:1;;;10239:31;10287:19;;49898:146:0::1;9915:397:1::0;49898:146:0::1;50057:16;50068:4;50057:10;:16::i;:::-;50084:28;50107:4;50084:22;:28::i;:::-;50129:11:::0;;50125:341:::1;;50171:11:::0;;:24:::1;::::0;50187:7;50171:15:::1;:24::i;:::-;50157:38:::0;;50225:12:::1;::::0;::::1;::::0;:25:::1;::::0;50242:7;50225:16:::1;:25::i;:::-;50210:12;::::0;::::1;:40:::0;50277:12;;50302:4:::1;-1:-1:-1::0;;;;;50269:38:0;;::::1;50277:12:::0;::::1;50269:38;50265:127;;;50347:16;::::0;:29:::1;::::0;50368:7;50347:20:::1;:29::i;:::-;50328:16;:48:::0;50265:127:::1;50406:48;16069:10:::0;50406:12;;-1:-1:-1;;;;;50406:12:0::1;::::0;50446:7;50406:25:::1;:48::i;:::-;50510:20;::::0;::::1;::::0;50494:11;;:47:::1;::::0;50536:4:::1;::::0;50494:37:::1;::::0;:15:::1;:37::i;:47::-;50476:15;::::0;::::1;:65:::0;50575:15:::1;50552:20;::::0;::::1;:38:::0;50606:37:::1;::::0;15476:25:1;;;50629:4:0;;16069:10;;50606:37:::1;::::0;15464:2:1;15449:18;50606:37:0::1;;;;;;;;-1:-1:-1::0;;20062:1:0;21014:22;;-1:-1:-1;;49369:1282:0:o;43488:760::-;43540:21;43564:8;43573:4;43564:14;;;;;;;;:::i;:::-;;;;;;;;;;;43540:38;;43609:4;:20;;;43593:12;:36;43589:75;;43646:7;43488:760;:::o;43589:75::-;43695:12;;;;43722:13;;;:37;;-1:-1:-1;43739:15:0;;;;:20;43722:37;43718:126;;;-1:-1:-1;43799:12:0;43776:20;;;;:35;-1:-1:-1;43488:760:0:o;43718:126::-;43856:18;43877:49;43891:4;:20;;;43913:12;43877:13;:49::i;:::-;43856:70;;43937:18;43958:112;44054:15;;43958:77;44019:4;:15;;;43958:42;43987:12;;43958:10;:28;;:42;;;;:::i;:112::-;43937:133;;44106:88;44145:38;44170:4;:12;;;44145:20;44160:4;44145:10;:14;;:20;;;;:::i;:38::-;44106:20;;;;;:24;:88::i;:::-;44083:20;;;:111;-1:-1:-1;;44228:12:0;44205:20;;;;:35;;;;-1:-1:-1;;43488:760:0:o;43232:180::-;43294:8;:15;43277:14;43320:85;43348:6;43342:3;:12;43320:85;;;43378:15;43389:3;43378:10;:15::i;:::-;43356:5;;;:::i;:::-;;;43320:85;;;;43266:146;43232:180::o;40440:912::-;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;36342:4:::1;40705:41;::::0;::::1;;;40683:116;;;::::0;-1:-1:-1;;;40683:116:0;;9008:2:1;40683:116:0::1;::::0;::::1;8990:21:1::0;9047:2;9027:18;;;9020:30;-1:-1:-1;;;9066:18:1;;;9059:55;9131:18;;40683:116:0::1;8806:349:1::0;40683:116:0::1;36238:7;40832:16;:44;;40810:123;;;::::0;-1:-1:-1;;;40810:123:0;;13152:2:1;40810:123:0::1;::::0;::::1;13134:21:1::0;13191:2;13171:18;;;13164:30;13230:31;13210:18;;;13203:59;13279:18;;40810:123:0::1;12950:353:1::0;40810:123:0::1;40948:11;40944:61;;;40976:17;:15;:17::i;:::-;41035:87;41100:11;41035:46;41055:8;41064:4;41055:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;41035:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:87::i;:::-;41017:15;:105;;;;41161:11;41133:8;41142:4;41133:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;41213:13;41183:8;41192:4;41183:14;;;;;;;;:::i;:::-;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;41270:16;41237:8;41246:4;41237:14;;;;;;;;:::i;:::-;;;;;;;;;;;:30;;:49;;;;41329:15;41297:8;41306:4;41297:14;;;;;;;;:::i;:::-;;;;;;;;;;;:29;;:47;;;;40440:912:::0;;;;;;:::o;17789:94::-;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;17854:21:::1;17872:1;17854:9;:21::i;:::-;17789:94::o:0;54688:314::-;54776:10;;-1:-1:-1;;;;;54776:10:0;16069;-1:-1:-1;;;;;54760:26:0;;54752:63;;;;-1:-1:-1;;;54752:63:0;;13868:2:1;54752:63:0;;;13850:21:1;13907:2;13887:18;;;13880:30;13946:26;13926:18;;;13919:54;13990:18;;54752:63:0;13666:348:1;54752:63:0;-1:-1:-1;;;;;54834:25:0;;54826:57;;;;-1:-1:-1;;;54826:57:0;;9769:2:1;54826:57:0;;;9751:21:1;9808:2;9788:18;;;9781:30;-1:-1:-1;;;9827:18:1;;;9820:49;9886:18;;54826:57:0;9567:343:1;54826:57:0;54933:10;;54901:56;;;-1:-1:-1;;;;;54933:10:0;;;4687:34:1;;4757:15;;;4752:2;4737:18;;4730:43;54901:56:0;;16069:10;;54901:56;;;;;;;;;54970:10;:24;;-1:-1:-1;;;;;;54970:24:0;-1:-1:-1;;;;;54970:24:0;;;;;;;;;;54688:314::o;38377:153::-;38476:7;38508:14;:3;38516:5;38508:7;:14::i;:::-;38501:21;38377:153;-1:-1:-1;;;38377:153:0:o;38584:375::-;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;38659:10:::1;;38644:12;:25;38636:65;;;::::0;-1:-1:-1;;;38636:65:0;;12044:2:1;38636:65:0::1;::::0;::::1;12026:21:1::0;12083:2;12063:18;;;12056:30;12122:29;12102:18;;;12095:57;12169:18;;38636:65:0::1;11842:351:1::0;38636:65:0::1;38731:8;:15:::0;38714:14:::1;38757:157;38785:6;38779:3;:12;38757:157;;;38815:21;38839:8;38848:3;38839:13;;;;;;;;:::i;:::-;;;;;;;;;;;38815:37;;38890:12;38867:4;:20;;:35;;;;38800:114;38793:5;;;;:::i;:::-;;;38757:157;;;-1:-1:-1::0;;38939:12:0::1;38926:10;:25:::0;38584:375::o;42504:296::-;42608:7;42657:14;;;:8;:14;;;;;;;;-1:-1:-1;;;;;42657:21:0;;;;;;;;;42713:8;:14;;42608:7;;42713:8;42666:4;;42713:14;;;;;;:::i;:::-;;;;;;;;;;;42689:38;;42747:45;42772:4;:19;;;42747:4;:20;;;:24;;:45;;;;:::i;:::-;42740:52;42504:296;-1:-1:-1;;;;;42504:296:0:o;53935:180::-;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;54019:26:0;::::1;54011:59;;;::::0;-1:-1:-1;;;54011:59:0;;8256:2:1;54011:59:0::1;::::0;::::1;8238:21:1::0;8295:2;8275:18;;;8268:30;-1:-1:-1;;;8314:18:1;;;8307:50;8374:18;;54011:59:0::1;8054:344:1::0;54011:59:0::1;54081:11;:26:::0;;-1:-1:-1;;;;;;54081:26:0::1;-1:-1:-1::0;;;;;54081:26:0;;;::::1;::::0;;;::::1;::::0;;53935:180::o;47880:1457::-;20106:1;20702:7;;:19;;20694:63;;;;-1:-1:-1;;;20694:63:0;;14632:2:1;20694:63:0;;;14614:21:1;14671:2;14651:18;;;14644:30;14710:33;14690:18;;;14683:61;14761:18;;20694:63:0;14430:355:1;20694:63:0;20106:1;20835:7;:18;47997:10:::1;::::0;47981:12:::1;:26;;47959:122;;;::::0;-1:-1:-1;;;47959:122:0;;11268:2:1;47959:122:0::1;::::0;::::1;11250:21:1::0;11307:2;11287:18;;;11280:30;11346:34;11326:18;;;11319:62;-1:-1:-1;;;11397:18:1;;;11390:44;11451:19;;47959:122:0::1;11066:410:1::0;47959:122:0::1;48094:21;48118:8;48127:4;48118:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;48167;;;:8:::1;:14:::0;;;;;;48118::::1;::::0;;::::1;;::::0;-1:-1:-1;48118:14:0;48182:12:::1;16069:10:::0;;15989:98;48182:12:::1;-1:-1:-1::0;;;;;48167:28:0::1;-1:-1:-1::0;;;;;48167:28:0::1;;;;;;;;;;;;48143:52;;48208:16;48219:4;48208:10;:16::i;:::-;48235:28;48258:4;48235:22;:28::i;:::-;48280:11:::0;;48276:877:::1;;48332:12:::0;;:37:::1;::::0;-1:-1:-1;;;48332:37:0;;48363:4:::1;48332:37;::::0;::::1;4413:51:1::0;48308:21:0::1;::::0;-1:-1:-1;;;;;48332:12:0::1;::::0;:22:::1;::::0;4386:18:1;;48332:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48308:61:::0;-1:-1:-1;48384:67:0::1;16069:10:::0;48384:12;;-1:-1:-1;;;;;48384:12:0::1;::::0;48436:4:::1;48443:7:::0;48384:29:::1;:67::i;:::-;48489:12:::0;;:37:::1;::::0;-1:-1:-1;;;48489:37:0;;48520:4:::1;48489:37;::::0;::::1;4413:51:1::0;48466:20:0::1;::::0;-1:-1:-1;;;;;48489:12:0::1;::::0;:22:::1;::::0;4386:18:1;;48489:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48466:60:::0;-1:-1:-1;48553:31:0::1;48466:60:::0;48570:13;48553:16:::1;:31::i;:::-;48605:17;::::0;::::1;::::0;48543:41;;-1:-1:-1;48605:17:0::1;;:21:::0;48601:288:::1;;48680:17;::::0;::::1;::::0;48647:18:::1;::::0;48668:41:::1;::::0;48703:5:::1;::::0;48668:30:::1;::::0;:7;;48680:17:::1;;48668:11;:30::i;:41::-;48647:62:::0;-1:-1:-1;48732:14:0;;48728:146:::1;;48771:27;48781:4;48787:10;48771:9;:27::i;:::-;48831:23;:7:::0;48843:10;48831:11:::1;:23::i;:::-;48821:33;;48728:146;48628:261;48601:288;48919:11:::0;;:24:::1;::::0;48935:7;48919:15:::1;:24::i;:::-;48905:38:::0;;48973:12:::1;::::0;::::1;::::0;:25:::1;::::0;48990:7;48973:16:::1;:25::i;:::-;48958:12;::::0;::::1;:40:::0;49027:12;;49052:4:::1;-1:-1:-1::0;;;;;49019:38:0;;::::1;49027:12:::0;::::1;49019:38;49015:127;;;49097:16;::::0;:29:::1;::::0;49118:7;49097:20:::1;:29::i;:::-;49078:16;:48:::0;49015:127:::1;48293:860;;48276:877;49197:20;::::0;::::1;::::0;49181:11;;:47:::1;::::0;49223:4:::1;::::0;49181:37:::1;::::0;:15:::1;:37::i;:47::-;49163:15;::::0;::::1;:65:::0;49262:15:::1;49239:20;::::0;::::1;:38:::0;49293:36:::1;::::0;15476:25:1;;;49315:4:0;;16069:10;;49293:36:::1;::::0;15464:2:1;15449:18;49293:36:0::1;15330:177:1::0;18038:229:0;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;18141:22:0;::::1;18119:110;;;::::0;-1:-1:-1;;;18119:110:0;;9362:2:1;18119:110:0::1;::::0;::::1;9344:21:1::0;9401:2;9381:18;;;9374:30;9440:34;9420:18;;;9413:62;-1:-1:-1;;;9491:18:1;;;9484:36;9537:19;;18119:110:0::1;9160:402:1::0;18119:110:0::1;18240:19;18250:8;18240:9;:19::i;:::-;18038:229:::0;:::o;54123:386::-;17184:7;17211:6;-1:-1:-1;;;;;17211:6:0;16069:10;17358:23;17350:68;;;;-1:-1:-1;;;17350:68:0;;;;;;;:::i;:::-;54325:15;54298:24:::1;54313:9:::0;54298:12;:24:::1;:::i;:::-;:42;;;;:::i;:::-;:51;;54344:5;54298:51;54276:114;;;::::0;-1:-1:-1;;;54276:114:0;;10926:2:1;54276:114:0::1;::::0;::::1;10908:21:1::0;10965:2;10945:18;;;10938:30;-1:-1:-1;;;10984:18:1;;;10977:43;11037:18;;54276:114:0::1;10724:337:1::0;54276:114:0::1;54401:11;:26:::0;;-1:-1:-1;;54438:20:0;54401:26;::::1;::::0;;::::1;;-1:-1:-1::0;;54438:20:0;;;;;::::1;::::0;;;::::1;::::0;;;::::1;-1:-1:-1::0;;54469:32:0::1;-1:-1:-1::0;;;54469:32:0;;;::::1;;::::0;;;::::1;::::0;;54123:386::o;23912:98::-;23970:7;23997:5;24001:1;23997;:5;:::i;24650:98::-;24708:7;24735:5;24739:1;24735;:5;:::i;25049:98::-;25107:7;25134:5;25138:1;25134;:5;:::i;24293:98::-;24351:7;24378:5;24382:1;24378;:5;:::i;50695:1597::-;50761:21;50785:8;50794:4;50785:14;;;;;;;;:::i;:::-;;;;;;;;;50834;;;:8;:14;;;;;;50785;;;;;;-1:-1:-1;50785:14:0;50849:12;16069:10;;15989:98;50849:12;-1:-1:-1;;;;;50834:28:0;-1:-1:-1;;;;;50834:28:0;;;;;;;;;;;;50810:52;;50879:4;:21;;;50904:1;50879:26;:56;;;;;50925:10;;50909:12;:26;;50879:56;50875:154;;;50996:20;;;;50976:41;;:15;;:19;:41::i;:::-;50952:21;;;:65;50875:154;51041:15;51059:92;51125:4;:15;;;51059:47;51101:4;51059:37;51075:4;:20;;;51059:4;:11;;;:15;;:37;;;;:::i;:92::-;51041:110;-1:-1:-1;51166:30:0;51177:4;16069:10;42863:286;:::i;51166:30::-;51162:1123;;;51227:1;51217:7;:11;:38;;;;51254:1;51232:4;:19;;;:23;51217:38;51213:823;;;51276:20;51299:32;51311:4;:19;;;51299:7;:11;;:32;;;;:::i;:::-;51276:55;-1:-1:-1;51383:26:0;51412:105;16069:10;51486:12;51412:16;:105::i;:::-;51383:134;-1:-1:-1;51536:28:0;51567:76;:12;51383:134;51567:16;:76::i;:::-;51536:107;;51720:115;51814:20;51720:67;51767:4;:19;;;51720:20;;:46;;:67;;;;:::i;:115::-;51697:20;:138;51854:19;;;:42;;;51981:20;;;;51939:81;;:15;;:19;:81::i;:::-;51915:21;;;:105;-1:-1:-1;;;51213:823:0;51162:1123;;;52057:11;;52053:232;;52107:19;;;;:32;;52131:7;52107:23;:32::i;:::-;52085:19;;;:54;52177:20;;:33;;52202:7;52177:24;:33::i;:::-;52154:20;:56;52230:43;;15476:25:1;;;52259:4:0;;16069:10;;52230:43;;15464:2:1;15449:18;52230:43:0;;;;;;;52053:232;50750:1542;;;50695:1597;:::o;11674:248::-;11845:58;;-1:-1:-1;;;;;5356:32:1;;11845:58:0;;;5338:51:1;5405:18;;;5398:34;;;11791:123:0;;11825:5;;-1:-1:-1;;;11868:23:0;5311:18:1;;11845:58:0;;;;-1:-1:-1;;11845:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;11845:58:0;-1:-1:-1;;;;;;11845:58:0;;;;;;;;;;11791:19;:123::i;:::-;11674:248;;;:::o;18275:173::-;18331:16;18350:6;;-1:-1:-1;;;;;18367:17:0;;;-1:-1:-1;;;;;;18367:17:0;;;;;;18400:40;;18350:6;;;;;;;18400:40;;18331:16;18400:40;18320:128;18275:173;:::o;11930:285::-;12128:68;;-1:-1:-1;;;;;5042:15:1;;;12128:68:0;;;5024:34:1;5094:15;;5074:18;;;5067:43;5126:18;;;5119:34;;;12074:133:0;;12108:5;;-1:-1:-1;;;12151:27:0;4959:18:1;;12128:68:0;4784:375:1;44301:1507:0;44373:20;44396:8;44405:4;44396:14;;;;;;;;:::i;:::-;;;;;;;;;44373:37;;;;;;;;44396:14;;;;;;;44373:37;;-1:-1:-1;;;;;44373:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44478:8;;44373:37;;-1:-1:-1;44463:35:0;;44492:5;;44463:24;;:10;;44478:8;;;;;44463:14;:24::i;:35::-;44442:56;-1:-1:-1;44513:14:0;;44509:98;;44570:12;;44544;;:51;;-1:-1:-1;;;;;44544:25:0;;;;44570:12;44584:10;44544:25;:51::i;:::-;44702:14;;44660:24;;44687:41;;44722:5;;44687:30;;:10;;-1:-1:-1;;;44702:14:0;;;;44687;:30::i;:41::-;44660:68;;44762:1;44743:16;:20;:49;;;;-1:-1:-1;44767:11:0;;-1:-1:-1;;;;;44767:11:0;:25;;44743:49;44739:138;;;44835:11;;44809:12;;:56;;-1:-1:-1;;;;;44809:25:0;;;;44835:11;44848:16;44809:25;:56::i;:::-;44921:21;44945:72;44990:16;44945:26;:10;44960;44945:14;:26::i;:72::-;45040:10;;44921:96;;-1:-1:-1;;;;;;45040:10:0;45032:33;;;;:54;;;45085:1;45069:13;:17;45032:54;45028:773;;;45103:20;45126;:13;45144:1;45126:17;:20::i;:::-;45103:43;-1:-1:-1;45161:18:0;45182:31;:13;45103:43;45182:17;:31::i;:::-;45161:52;;45270:24;45296:12;45312:141;45353:4;:12;;;45385;45432:4;45312:14;:141::i;:::-;45269:184;;;;45539:7;:31;;;;;45569:1;45550:16;:20;45539:31;45535:255;;;45637:12;;45745:10;;45591:183;;45637:12;45673:10;;45706:16;;-1:-1:-1;;;;;45745:10:0;45591:15;:183::i;:::-;;45535:255;45088:713;;;;45028:773;44362:1446;;;;44301:1507;;:::o;52405:1320::-;52496:7;52535:1;52525:7;:11;:63;;;;-1:-1:-1;52572:16:0;;52540:29;;-1:-1:-1;;;52540:29:0;;52563:4;52540:29;;;4413:51:1;52540:4:0;-1:-1:-1;;;;;52540:14:0;;;;4386:18:1;;52540:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:48;52525:63;52521:1178;;;52836:16;;52784:29;;-1:-1:-1;;;52784:29:0;;52807:4;52784:29;;;4413:51:1;52766:15:0;;52784:83;;-1:-1:-1;;;;;52784:4:0;:14;;;;4386:18:1;;52784:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:83::-;52766:101;;52897:7;52886;:18;52882:76;;52935:7;52925:17;;52882:76;53070:17;;53028:27;;53058:73;;53111:5;;53058:30;;:7;;53070:17;;53058:11;:30::i;:73::-;53028:103;-1:-1:-1;53150:23:0;;53146:107;;53194:43;-1:-1:-1;;;;;53194:4:0;:17;53212:3;53217:19;53194:17;:43::i;:::-;53323:19;53313:7;:29;53309:348;;;-1:-1:-1;;;;;53363:4:0;:12;;53406:15;53445:32;:7;53457:19;53445:11;:32::i;:::-;53363:133;;-1:-1:-1;;;;;;53363:133:0;;;;;;;-1:-1:-1;;;;;5356:32:1;;;53363:133:0;;;5338:51:1;5405:18;;;5398:34;5311:18;;53363:133:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;53515:15:0;:26;;53564:3;53590:32;:7;53602:19;53590:11;:32::i;:::-;53515:126;;-1:-1:-1;;;;;;53515:126:0;;;;;;;-1:-1:-1;;;;;5356:32:1;;;53515:126:0;;;5338:51:1;5405:18;;;5398:34;5311:18;;53515:126:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53309:348;53680:7;53673:14;;;;;;52521:1178;-1:-1:-1;53716:1:0;52405:1320;;;;:::o;14641:802::-;15065:23;15091:106;15133:4;15091:106;;;;;;;;;;;;;;;;;15099:5;-1:-1:-1;;;;;15091:27:0;;;:106;;;;;:::i;:::-;15212:17;;15065:132;;-1:-1:-1;15212:21:0;15208:228;;15327:10;15316:30;;;;;;;;;;;;:::i;:::-;15290:134;;;;-1:-1:-1;;;15290:134:0;;14221:2:1;15290:134:0;;;14203:21:1;14260:2;14240:18;;;14233:30;14299:34;14279:18;;;14272:62;-1:-1:-1;;;14350:18:1;;;14343:40;14400:19;;15290:134:0;14019:406:1;45869:1083:0;46145:10;;46114:57;;-1:-1:-1;;;46114:57:0;;-1:-1:-1;;;;;46145:10:0;;;46114:57;;;5338:51:1;5405:18;;;5398:34;;;46003:17:0;;;;46114:22;;;;;;5311:18:1;;46114:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;46276:16:0;;;46290:1;46276:16;;;;;;;;46252:21;;46276:16;;;;;;;;;;-1:-1:-1;46276:16:0;46252:40;;46313:6;46303:4;46308:1;46303:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;46303:16:0;;;:7;;;;;;;;;;:16;;;;46340:10;;:17;;;-1:-1:-1;;;46340:17:0;;;;:10;;;;;:15;;:17;;;;;46303:7;;46340:17;;;;;:10;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46330:4;46335:1;46330:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;46330:27:0;;;:7;;;;;;;;;:27;46459:10;;46420:11;;;;;46459:10;:61;46539:12;46396:21;46618:4;46420:3;46663:24;:15;46683:3;46663:19;:24::i;:::-;46459:243;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46442:503;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46900:5;46890:15;;46932:1;46920:13;;46811:134;46442:503;;;46739:30;-1:-1:-1;;;;;46739:11:0;;;46755:13;46739:15;:30::i;:::-;46727:42;;46794:4;46784:14;;46442:503;46036:916;;45869:1083;;;;;;:::o;47008:805::-;47287:10;;47256:57;;-1:-1:-1;;;47256:57:0;;-1:-1:-1;;;;;47287:10:0;;;47256:57;;;5338:51:1;5405:18;;;5398:34;;;47164:12:0;;47256:22;;;;;5311:18:1;;47256:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;47373:10:0;;-1:-1:-1;;;;;47373:10:0;:26;47407:10;47437:6;47462:12;47373:10;;47587:3;47609:24;:15;47629:3;47609:19;:24::i;:::-;47373:275;;;;;;-1:-1:-1;;;;;;47373:275:0;;;-1:-1:-1;;;;;5802:15:1;;;47373:275:0;;;5784:34:1;5834:18;;;5827:34;;;;5877:18;;;5870:34;;;;5920:18;;;5913:34;;;;5984:15;;;5963:19;;;5956:44;6016:19;;;6009:35;;;;5718:19;;47373:275:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47373:275:0;;;;;;;;-1:-1:-1;;47373:275:0;;;;;;;;;;;;:::i;:::-;;;47356:450;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47789:5;47779:15;;47700:106;47356:450;;;;;;47683:4;47673:14;;47356:450;47008:805;;;;;;:::o;6470:229::-;6607:12;6639:52;6661:6;6669:4;6675:1;6678:12;6607;3890:20;;8010:60;;;;-1:-1:-1;;;8010:60:0;;13510:2:1;8010:60:0;;;13492:21:1;13549:2;13529:18;;;13522:30;13588:31;13568:18;;;13561:59;13637:18;;8010:60:0;13308:353:1;8010:60:0;8084:12;8098:23;8125:6;-1:-1:-1;;;;;8125:11:0;8144:5;8165:4;8125:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8083:97;;;;8198:52;8216:7;8225:10;8237:12;8198:17;:52::i;:::-;8191:59;7686:572;-1:-1:-1;;;;;;;7686:572:0:o;10429:712::-;10579:12;10608:7;10604:530;;;-1:-1:-1;10639:10:0;10632:17;;10604:530;10753:17;;:21;10749:374;;10951:10;10945:17;11012:15;10999:10;10995:2;10991:19;10984:44;10749:374;11094:12;11087:20;;-1:-1:-1;;;11087:20:0;;;;;;;;:::i;14:159:1:-;81:20;;141:6;130:18;;120:29;;110:57;;163:1;160;153:12;110:57;14:159;;;:::o;178:247::-;237:6;290:2;278:9;269:7;265:23;261:32;258:52;;;306:1;303;296:12;258:52;345:9;332:23;364:31;389:5;364:31;:::i;430:251::-;500:6;553:2;541:9;532:7;528:23;524:32;521:52;;;569:1;566;559:12;521:52;601:9;595:16;620:31;645:5;620:31;:::i;686:245::-;753:6;806:2;794:9;785:7;781:23;777:32;774:52;;;822:1;819;812:12;774:52;854:9;848:16;873:28;895:5;873:28;:::i;936:184::-;994:6;1047:2;1035:9;1026:7;1022:23;1018:32;1015:52;;;1063:1;1060;1053:12;1015:52;1086:28;1104:9;1086:28;:::i;1125:328::-;1199:6;1207;1215;1268:2;1256:9;1247:7;1243:23;1239:32;1236:52;;;1284:1;1281;1274:12;1236:52;1307:28;1325:9;1307:28;:::i;:::-;1297:38;;1354:37;1387:2;1376:9;1372:18;1354:37;:::i;:::-;1344:47;;1410:37;1443:2;1432:9;1428:18;1410:37;:::i;:::-;1400:47;;1125:328;;;;;:::o;1458:180::-;1517:6;1570:2;1558:9;1549:7;1545:23;1541:32;1538:52;;;1586:1;1583;1576:12;1538:52;-1:-1:-1;1609:23:1;;1458:180;-1:-1:-1;1458:180:1:o;1643:184::-;1713:6;1766:2;1754:9;1745:7;1741:23;1737:32;1734:52;;;1782:1;1779;1772:12;1734:52;-1:-1:-1;1805:16:1;;1643:184;-1:-1:-1;1643:184:1:o;1832:315::-;1900:6;1908;1961:2;1949:9;1940:7;1936:23;1932:32;1929:52;;;1977:1;1974;1967:12;1929:52;2013:9;2000:23;1990:33;;2073:2;2062:9;2058:18;2045:32;2086:31;2111:5;2086:31;:::i;:::-;2136:5;2126:15;;;1832:315;;;;;:::o;2152:674::-;2265:6;2273;2281;2289;2297;2305;2358:3;2346:9;2337:7;2333:23;2329:33;2326:53;;;2375:1;2372;2365:12;2326:53;2411:9;2398:23;2388:33;;2471:2;2460:9;2456:18;2443:32;2484:31;2509:5;2484:31;:::i;:::-;2534:5;-1:-1:-1;2558:37:1;2591:2;2576:18;;2558:37;:::i;:::-;2548:47;;2642:2;2631:9;2627:18;2614:32;2604:42;;2693:3;2682:9;2678:19;2665:33;2655:43;;2750:3;2739:9;2735:19;2722:33;2764:30;2786:7;2764:30;:::i;:::-;2813:7;2803:17;;;2152:674;;;;;;;;:::o;2831:248::-;2899:6;2907;2960:2;2948:9;2939:7;2935:23;2931:32;2928:52;;;2976:1;2973;2966:12;2928:52;-1:-1:-1;;2999:23:1;;;3069:2;3054:18;;;3041:32;;-1:-1:-1;2831:248:1:o;3084:588::-;3184:6;3192;3200;3208;3216;3224;3277:3;3265:9;3256:7;3252:23;3248:33;3245:53;;;3294:1;3291;3284:12;3245:53;3330:9;3317:23;3307:33;;3387:2;3376:9;3372:18;3359:32;3349:42;;3410:37;3443:2;3432:9;3428:18;3410:37;:::i;3677:306::-;3765:6;3773;3781;3834:2;3822:9;3813:7;3809:23;3805:32;3802:52;;;3850:1;3847;3840:12;3802:52;3879:9;3873:16;3863:26;;3929:2;3918:9;3914:18;3908:25;3898:35;;3973:2;3962:9;3958:18;3952:25;3942:35;;3677:306;;;;;:::o;3988:274::-;4117:3;4155:6;4149:13;4171:53;4217:6;4212:3;4205:4;4197:6;4193:17;4171:53;:::i;:::-;4240:16;;;;;3988:274;-1:-1:-1;;3988:274:1:o;7666:383::-;7815:2;7804:9;7797:21;7778:4;7847:6;7841:13;7890:6;7885:2;7874:9;7870:18;7863:34;7906:66;7965:6;7960:2;7949:9;7945:18;7940:2;7932:6;7928:15;7906:66;:::i;:::-;8033:2;8012:15;-1:-1:-1;;8008:29:1;7993:45;;;;8040:2;7989:54;;7666:383;-1:-1:-1;;7666:383:1:o;11481:356::-;11683:2;11665:21;;;11702:18;;;11695:30;11761:34;11756:2;11741:18;;11734:62;11828:2;11813:18;;11481:356::o;15512:988::-;15782:4;15830:3;15819:9;15815:19;15861:6;15850:9;15843:25;15887:2;15925:6;15920:2;15909:9;15905:18;15898:34;15968:3;15963:2;15952:9;15948:18;15941:31;15992:6;16027;16021:13;16058:6;16050;16043:22;16096:3;16085:9;16081:19;16074:26;;16135:2;16127:6;16123:15;16109:29;;16156:1;16166:195;16180:6;16177:1;16174:13;16166:195;;;16245:13;;-1:-1:-1;;;;;16241:39:1;16229:52;;16336:15;;;;16301:12;;;;16277:1;16195:9;16166:195;;;-1:-1:-1;;;;;;;16417:32:1;;;;16412:2;16397:18;;16390:60;-1:-1:-1;;;16481:3:1;16466:19;16459:35;16378:3;15512:988;-1:-1:-1;;;15512:988:1:o;17226:224::-;17265:3;17293:6;17326:2;17323:1;17319:10;17356:2;17353:1;17349:10;17387:3;17383:2;17379:12;17374:3;17371:21;17368:47;;;17395:18;;:::i;:::-;17431:13;;17226:224;-1:-1:-1;;;;17226:224:1:o;17455:128::-;17495:3;17526:1;17522:6;17519:1;17516:13;17513:39;;;17532:18;;:::i;:::-;-1:-1:-1;17568:9:1;;17455:128::o;17588:217::-;17628:1;17654;17644:132;;17698:10;17693:3;17689:20;17686:1;17679:31;17733:4;17730:1;17723:15;17761:4;17758:1;17751:15;17644:132;-1:-1:-1;17790:9:1;;17588:217::o;17810:168::-;17850:7;17916:1;17912;17908:6;17904:14;17901:1;17898:21;17893:1;17886:9;17879:17;17875:45;17872:71;;;17923:18;;:::i;:::-;-1:-1:-1;17963:9:1;;17810:168::o;17983:125::-;18023:4;18051:1;18048;18045:8;18042:34;;;18056:18;;:::i;:::-;-1:-1:-1;18093:9:1;;17983:125::o;18113:258::-;18185:1;18195:113;18209:6;18206:1;18203:13;18195:113;;;18285:11;;;18279:18;18266:11;;;18259:39;18231:2;18224:10;18195:113;;;18326:6;18323:1;18320:13;18317:48;;;-1:-1:-1;;18361:1:1;18343:16;;18336:27;18113:258::o;18376:135::-;18415:3;-1:-1:-1;;18436:17:1;;18433:43;;;18456:18;;:::i;:::-;-1:-1:-1;18503:1:1;18492:13;;18376:135::o;18516:127::-;18577:10;18572:3;18568:20;18565:1;18558:31;18608:4;18605:1;18598:15;18632:4;18629:1;18622:15;18648:127;18709:10;18704:3;18700:20;18697:1;18690:31;18740:4;18737:1;18730:15;18764:4;18761:1;18754:15;18912:131;-1:-1:-1;;;;;18987:31:1;;18977:42;;18967:70;;19033:1;19030;19023:12;19048:118;19134:5;19127:13;19120:21;19113:5;19110:32;19100:60;;19156:1;19153;19146:12

ipfs://e4e65ee5bb0493e303e51db7de859821b6364ff3524168663e5deb8f3b007e0a