Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(
•    - function mulDiv(
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
• library AddressUpgradeable
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function verifyCallResult(
•    - function _disableInitializers()
•    - function __Context_init()
•    - function __Context_init_unchained()
•    - function _msgSender()
•    - function _msgData()
•    - function __Ownable_init()
•    - function __Ownable_init_unchained()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
•  contract LPTokenWrapperInitializab ...
•    - function __LPTokenWrapper_init(addres ...
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function stake(uint256 amount)
•    - function withdraw(uint256 amount)
•  contract BeefyBoost is LPTokenWrap ... *
•    - function initialize(
•    - function lastTimeRewardApplicable()
•    - function rewardPerToken()
•    - function earned(address account)
•    - function stake(uint256 amount)
•    - function withdraw(uint256 amount)
•    - function exit()
•    - function getReward()
•    - function setRewardDuration(uint256 _d ...
•    - function setTreasuryFee(uint256 _fee)
•    - function setTreasury(address _treasur ...
•    - function openPreStake()
•    - function closePreStake()
•    - function setNotifier(address _notifie ...
•    - function _notify(uint256 reward)
•    - function notifyAmount(uint256 _amount ...
•    - function notifyAlreadySent()
•    - function inCaseTokensGetStuck(address ...
•    - function inCaseTokensGetStuck(address ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-02-07
*/

// File: @openzeppelin-4/contracts/token/ERC20/IERC20.sol

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin-4/contracts/utils/math/Math.sol

// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`.
        // We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`.
        // This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`.
        // Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a
        // good first aproximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1;
        uint256 x = a;
        if (x >> 128 > 0) {
            x >>= 128;
            result <<= 64;
        }
        if (x >> 64 > 0) {
            x >>= 64;
            result <<= 32;
        }
        if (x >> 32 > 0) {
            x >>= 32;
            result <<= 16;
        }
        if (x >> 16 > 0) {
            x >>= 16;
            result <<= 8;
        }
        if (x >> 8 > 0) {
            x >>= 8;
            result <<= 4;
        }
        if (x >> 4 > 0) {
            x >>= 4;
            result <<= 2;
        }
        if (x >> 2 > 0) {
            result <<= 1;
        }

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

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

// File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol

// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return 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 Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol

// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

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

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

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

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

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
     * initialization step. This is essential to configure modules that are added through upgrades and that require
     * initialization.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

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

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

// File: @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

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

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

// File: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin-4/contracts/token/ERC20/extensions/draft-IERC20Permit.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

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

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

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

// File: @openzeppelin-4/contracts/utils/Address.sol

// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://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);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin-4/contracts/token/ERC20/utils/SafeERC20.sol

// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

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

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

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

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

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

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

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

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

// File: contracts/BIFI/utils/LPTokenWrapperInitializable.sol


pragma solidity ^0.8.0;


contract LPTokenWrapperInitializable is Initializable {
    using SafeERC20 for IERC20;

    IERC20 public stakedToken;

    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

    function __LPTokenWrapper_init(address _stakedToken) internal onlyInitializing {
        stakedToken = IERC20(_stakedToken);
    }

    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    function stake(uint256 amount) public virtual {
        _totalSupply += amount;
        _balances[msg.sender] += amount;
        stakedToken.safeTransferFrom(msg.sender, address(this), amount);
    }

    function withdraw(uint256 amount) public virtual {
        _totalSupply -= amount;
        _balances[msg.sender] -= amount;
        stakedToken.safeTransfer(msg.sender, amount);
    }
}

// File: contracts/BIFI/infra/BeefyBoost.sol


pragma solidity ^0.8.0;



contract BeefyBoost is LPTokenWrapperInitializable, OwnableUpgradeable {
    using SafeERC20 for IERC20;

    IERC20 public rewardToken;
    uint256 public duration;

    uint256 public periodFinish;
    uint256 public rewardRate;
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;
    uint256 public rewardBalance;

    address public manager;
    address public treasury;
    uint256 public treasuryFee;

    bool public isPreStake;

    mapping(address => bool) public notifiers;

    event RewardAdded(uint256 reward);
    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);

    function initialize(
        address _stakedToken,
        address _rewardToken,
        uint256 _duration,
        address _manager,
        address _treasury
    ) public initializer {
        __LPTokenWrapper_init(_stakedToken);
        __Ownable_init();
        rewardToken = IERC20(_rewardToken);
        duration = _duration;
        manager = _manager;
        treasury = _treasury;
        treasuryFee = 500;
    }

    modifier onlyManager() {
        require(msg.sender == manager || msg.sender == owner(), "!manager");
        _;
    }

    modifier onlyNotifier() {
        require(msg.sender == manager || msg.sender == owner() || notifiers[msg.sender], "!notifier");
        _;
    }

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = lastTimeRewardApplicable();
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, periodFinish);
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalSupply() == 0) {
            return rewardPerTokenStored;
        }
        return rewardPerTokenStored + ((lastTimeRewardApplicable() - lastUpdateTime) * rewardRate * 1e18 / totalSupply());
    }

    function earned(address account) public view returns (uint256) {
        return balanceOf(account) * (rewardPerToken() - userRewardPerTokenPaid[account]) / 1e18 + rewards[account];
    }

    // stake visibility is public as overriding LPTokenWrapper's stake() function
    function stake(uint256 amount) public override updateReward(msg.sender) {
        require(amount > 0, "Cannot stake 0");
        super.stake(amount);
        emit Staked(msg.sender, amount);
    }

    function withdraw(uint256 amount) public override updateReward(msg.sender) {
        require(amount > 0, "Cannot withdraw 0");
        super.withdraw(amount);
        emit Withdrawn(msg.sender, amount);
    }

    function exit() external {
        withdraw(balanceOf(msg.sender));
        getReward();
    }

    function getReward() public updateReward(msg.sender) {
        uint256 reward = earned(msg.sender);
        if (reward > 0) {
            rewards[msg.sender] = 0;
            rewardBalance -= reward;
            rewardToken.safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
    }

    function setRewardDuration(uint256 _duration) external onlyManager {
        require(block.timestamp >= periodFinish);
        duration = _duration;
    }

    function setTreasuryFee(uint256 _fee) external onlyManager {
        require(_fee <= 500);
        treasuryFee = _fee;
    }

    function setTreasury(address _treasury) external onlyManager {
        treasury = _treasury;
    }

    function openPreStake() external onlyManager {
        isPreStake = true;
    }

    function closePreStake() external onlyManager {
        isPreStake = false;
    }

    function setNotifier(address _notifier, bool _enable) external onlyManager {
        notifiers[_notifier] = _enable;
    }

    function _notify(uint256 reward) internal updateReward(address(0)) {
        uint256 fee = reward * treasuryFee / 10000;
        if (fee > 0) {
            rewardToken.safeTransfer(treasury, fee);
            reward -= fee;
        }
        require(reward != 0, "no rewards");
        if (block.timestamp >= periodFinish) {
            rewardRate = reward / duration;
        } else {
            uint256 remaining = periodFinish - block.timestamp;
            uint256 leftover = remaining * rewardRate;
            rewardRate = (reward + leftover) / duration;
        }
        lastUpdateTime = block.timestamp;
        periodFinish = block.timestamp + duration;
        rewardBalance += reward;
        isPreStake = false;
        emit RewardAdded(reward);
    }

    function notifyAmount(uint256 _amount) external onlyNotifier {
        rewardToken.safeTransferFrom(msg.sender, address(this), _amount);
        _notify(_amount);
    }

    function notifyAlreadySent() external onlyNotifier {
        uint256 balance = rewardToken.balanceOf(address(this));
        uint256 userRewards = rewardBalance;
        if (rewardToken == stakedToken) {
            userRewards = userRewards + totalSupply();
        }
        uint256 newRewards = balance - userRewards;
        _notify(newRewards);
    }

    function inCaseTokensGetStuck(address _token) external onlyManager {
        uint256 amount = IERC20(_token).balanceOf(address(this));
        inCaseTokensGetStuck(_token, msg.sender, amount);
    }

    function inCaseTokensGetStuck(address _token, address _to, uint _amount) public onlyManager {
        if (totalSupply() != 0) {
            require(_token != address(stakedToken), "!staked");
        }
        IERC20(_token).safeTransfer(_to, _amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"closePreStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"inCaseTokensGetStuck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"inCaseTokensGetStuck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_stakedToken","type":"address"},{"internalType":"address","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_duration","type":"uint256"},{"internalType":"address","name":"_manager","type":"address"},{"internalType":"address","name":"_treasury","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isPreStake","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"notifiers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notifyAlreadySent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"notifyAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"openPreStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_notifier","type":"address"},{"internalType":"bool","name":"_enable","type":"bool"}],"name":"setNotifier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_duration","type":"uint256"}],"name":"setRewardDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setTreasuryFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakedToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"treasuryFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

46545:6043:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48901:188;;;;;;:::i;:::-;;:::i;:::-;;;529:25:1;;;517:2;502:18;48901:188:0;;;;;;;;51742:363;;;:::i;:::-;;46930:42;;;;;;:::i;:::-;;;;;;;;;;;;;;46690:23;;;;;;45842:91;45913:12;;45842:91;;49388:212;;;;;;:::i;:::-;;:::i;50639:124::-;;;;;;:::i;:::-;;:::i;47411:436::-;;;;;;:::i;:::-;;:::i;49713:330::-;;;:::i;47016:22::-;;;;;-1:-1:-1;;;;;47016:22:0;;;;;;-1:-1:-1;;;;;1840:32:1;;;1822:51;;1810:2;1795:18;47016:22:0;1676:203:1;50548:83:0;;;:::i;47141:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2049:14:1;;2042:22;2024:41;;2012:2;1997:18;47141:41:0;1884:187:1;51563:171:0;;;;;;:::i;:::-;;:::i;47045:23::-;;;;;-1:-1:-1;;;;;47045:23:0;;;45941:110;;;;;;:::i;:::-;-1:-1:-1;;;;;46025:18:0;45998:7;46025:18;;;:9;:18;;;;;;;45941:110;28852:103;;;:::i;50216:127::-;;;;;;:::i;:::-;;:::i;46756:25::-;;;;;;48478:131;;;:::i;46866:57::-;;;;;;:::i;:::-;;;;;;;;;;;;;;28204:87;28277:6;;-1:-1:-1;;;;;28277:6:0;28204:87;;50459:81;;;:::i;49180:200::-;;;;;;:::i;:::-;;:::i;46979:28::-;;;;;;47110:22;;;;;;;;;50051:157;;;;;;:::i;:::-;;:::i;46788:29::-;;;;;;47075:26;;;;;;45579:25;;;;;;;;-1:-1:-1;;;;;45579:25:0;;;48617:276;;;:::i;52113:201::-;;;;;;:::i;:::-;;:::i;46824:35::-;;;;;;49608:97;;;:::i;46722:27::-;;;;;;50351:100;;;;;;:::i;:::-;;:::i;29110:201::-;;;;;;:::i;:::-;;:::i;52322:263::-;;;;;;:::i;:::-;;:::i;46658:25::-;;;;;-1:-1:-1;;;;;46658:25:0;;;48901:188;-1:-1:-1;;;;;49065:16:0;;48955:7;49065:16;;;:7;:16;;;;;;;;;49023:22;:31;;;;;;49058:4;;49004:16;:14;:16::i;:::-;:50;;;;:::i;:::-;-1:-1:-1;;;;;46025:18:0;;45998:7;46025:18;;;:9;:18;;;;;;48982:73;;;;:::i;:::-;:80;;;;:::i;:::-;:99;;;;:::i;:::-;48975:106;48901:188;-1:-1:-1;;48901:188:0:o;51742:363::-;48041:7;;-1:-1:-1;;;;;48041:7:0;48027:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;48052:10;:21;48027:46;:71;;;-1:-1:-1;48087:10:0;48077:21;;;;:9;:21;;;;;;;;48027:71;48019:93;;;;-1:-1:-1;;;48019:93:0;;3622:2:1;48019:93:0;;;3604:21:1;3661:1;3641:18;;;3634:29;-1:-1:-1;;;3679:18:1;;;3672:39;3728:18;;48019:93:0;;;;;;;;;51822:11:::1;::::0;:36:::1;::::0;-1:-1:-1;;;51822:36:0;;51852:4:::1;51822:36;::::0;::::1;1822:51:1::0;51804:15:0::1;::::0;-1:-1:-1;;;;;51822:11:0::1;::::0;:21:::1;::::0;1795:18:1;;51822:36:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;51891:13;::::0;51869:19:::1;51934:11:::0;51919::::1;::::0;51804:54;;-1:-1:-1;51891:13:0;;-1:-1:-1;;;;;51934:11:0;;;::::1;::::0;::::1;51919::::0;::::1;:26:::0;51915:100:::1;;45913:12:::0;;51976:27:::1;::::0;:11;:27:::1;:::i;:::-;51962:41;;51915:100;52025:18;52046:21;52056:11:::0;52046:7;:21:::1;:::i;:::-;52025:42;;52078:19;52086:10;52078:7;:19::i;:::-;51793:312;;;51742:363::o:0;49388:212::-;49451:10;48213:16;:14;:16::i;:::-;48190:20;:39;48257:26;:24;:26::i;:::-;48240:14;:43;-1:-1:-1;;;;;48298:21:0;;;48294:157;;48355:15;48362:7;48355:6;:15::i;:::-;-1:-1:-1;;;;;48336:16:0;;;;;;:7;:16;;;;;;;;:34;;;;48419:20;;48385:22;:31;;;;;;:54;48294:157;49491:1:::1;49482:6;:10;49474:40;;;::::0;-1:-1:-1;;;49474:40:0;;4148:2:1;49474:40:0::1;::::0;::::1;4130:21:1::0;4187:2;4167:18;;;4160:30;-1:-1:-1;;;4206:18:1;;;4199:47;4263:18;;49474:40:0::1;3946:341:1::0;49474:40:0::1;49525:22;49540:6;49525:14;:22::i;:::-;49563:29;::::0;529:25:1;;;49573:10:0::1;::::0;49563:29:::1;::::0;517:2:1;502:18;49563:29:0::1;;;;;;;;49388:212:::0;;:::o;50639:124::-;47911:7;;-1:-1:-1;;;;;47911:7:0;47897:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;47922:10;:21;47897:46;47889:67;;;;-1:-1:-1;;;47889:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50725:20:0;;;::::1;;::::0;;;:9:::1;:20;::::0;;;;:30;;-1:-1:-1;;50725:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;50639:124::o;47411:436::-;22753:19;22776:13;;;;;;22775:14;;22823:34;;;;-1:-1:-1;22841:12:0;;22856:1;22841:12;;;;:16;22823:34;22822:108;;;-1:-1:-1;22902:4:0;13519:19;:23;;;22863:66;;-1:-1:-1;22912:12:0;;;;;:17;22863:66;22800:204;;;;-1:-1:-1;;;22800:204:0;;4830:2:1;22800:204:0;;;4812:21:1;4869:2;4849:18;;;4842:30;4908:34;4888:18;;;4881:62;-1:-1:-1;;;4959:18:1;;;4952:44;5013:19;;22800:204:0;4628:410:1;22800:204:0;23015:12;:16;;-1:-1:-1;;23015:16:0;23030:1;23015:16;;;23042:67;;;;23077:13;:20;;-1:-1:-1;;23077:20:0;;;;;23042:67;47613:35:::1;47635:12;47613:21;:35::i;:::-;47659:16;:14;:16::i;:::-;47686:11;:34:::0;;-1:-1:-1;;;;;47686:34:0;;::::1;-1:-1:-1::0;;;;;;47686:34:0;;::::1;;::::0;;;47731:8:::1;:20:::0;;;47762:7:::1;:18:::0;;;;::::1;::::0;;::::1;;::::0;;47791:8:::1;:20:::0;;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;47836:3:::1;47822:11;:17:::0;23131:102;;;;23182:5;23166:21;;-1:-1:-1;;23166:21:0;;;23207:14;;-1:-1:-1;5195:36:1;;23207:14:0;;5183:2:1;5168:18;23207:14:0;;;;;;;23131:102;22742:498;47411:436;;;;;:::o;49713:330::-;49754:10;48213:16;:14;:16::i;:::-;48190:20;:39;48257:26;:24;:26::i;:::-;48240:14;:43;-1:-1:-1;;;;;48298:21:0;;;48294:157;;48355:15;48362:7;48355:6;:15::i;:::-;-1:-1:-1;;;;;48336:16:0;;;;;;:7;:16;;;;;;;;:34;;;;48419:20;;48385:22;:31;;;;;;:54;48294:157;49777:14:::1;49794:18;49801:10;49794:6;:18::i;:::-;49777:35:::0;-1:-1:-1;49827:10:0;;49823:213:::1;;49862:10;49876:1;49854:19:::0;;;:7:::1;:19;::::0;;;;:23;;;49892:13:::1;:23:::0;;49909:6;;49876:1;49892:23:::1;::::0;49909:6;;49892:23:::1;:::i;:::-;::::0;;;-1:-1:-1;;49930:11:0::1;::::0;:44:::1;::::0;-1:-1:-1;;;;;49930:11:0::1;49955:10;49967:6:::0;49930:24:::1;:44::i;:::-;49994:30;::::0;529:25:1;;;50005:10:0::1;::::0;49994:30:::1;::::0;517:2:1;502:18;49994:30:0::1;383:177:1::0;49823:213:0::1;49766:277;49713:330:::0;:::o;50548:83::-;47911:7;;-1:-1:-1;;;;;47911:7:0;47897:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;47922:10;:21;47897:46;47889:67;;;;-1:-1:-1;;;47889:67:0;;;;;;;:::i;:::-;50605:10:::1;:18:::0;;-1:-1:-1;;50605:18:0::1;::::0;;50548:83::o;51563:171::-;48041:7;;-1:-1:-1;;;;;48041:7:0;48027:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;48052:10;:21;48027:46;:71;;;-1:-1:-1;48087:10:0;48077:21;;;;:9;:21;;;;;;;;48027:71;48019:93;;;;-1:-1:-1;;;48019:93:0;;3622:2:1;48019:93:0;;;3604:21:1;3661:1;3641:18;;;3634:29;-1:-1:-1;;;3679:18:1;;;3672:39;3728:18;;48019:93:0;3420:332:1;48019:93:0;51635:11:::1;::::0;:64:::1;::::0;-1:-1:-1;;;;;51635:11:0::1;51664:10;51684:4;51691:7:::0;51635:28:::1;:64::i;:::-;51710:16;51718:7;51710;:16::i;:::-;51563:171:::0;:::o;28852:103::-;28090:13;:11;:13::i;:::-;28917:30:::1;28944:1;28917:18;:30::i;:::-;28852:103::o:0;50216:127::-;47911:7;;-1:-1:-1;;;;;47911:7:0;47897:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;47922:10;:21;47897:46;47889:67;;;;-1:-1:-1;;;47889:67:0;;;;;;;:::i;:::-;50302:3:::1;50294:4;:11;;50286:20;;;::::0;::::1;;50317:11;:18:::0;50216:127::o;48478:131::-;48535:7;48562:39;48571:15;48588:12;;48562:8;:39::i;:::-;48555:46;;48478:131;:::o;50459:81::-;47911:7;;-1:-1:-1;;;;;47911:7:0;47897:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;47922:10;:21;47897:46;47889:67;;;;-1:-1:-1;;;47889:67:0;;;;;;;:::i;:::-;50515:10:::1;:17:::0;;-1:-1:-1;;50515:17:0::1;50528:4;50515:17;::::0;;50459:81::o;49180:200::-;49240:10;48213:16;:14;:16::i;:::-;48190:20;:39;48257:26;:24;:26::i;:::-;48240:14;:43;-1:-1:-1;;;;;48298:21:0;;;48294:157;;48355:15;48362:7;48355:6;:15::i;:::-;-1:-1:-1;;;;;48336:16:0;;;;;;:7;:16;;;;;;;;:34;;;;48419:20;;48385:22;:31;;;;;;:54;48294:157;49280:1:::1;49271:6;:10;49263:37;;;::::0;-1:-1:-1;;;49263:37:0;;5444:2:1;49263:37:0::1;::::0;::::1;5426:21:1::0;5483:2;5463:18;;;5456:30;-1:-1:-1;;;5502:18:1;;;5495:44;5556:18;;49263:37:0::1;5242:338:1::0;49263:37:0::1;49311:19;49323:6;49311:11;:19::i;:::-;49346:26;::::0;529:25:1;;;49353:10:0::1;::::0;49346:26:::1;::::0;517:2:1;502:18;49346:26:0::1;383:177:1::0;50051:157:0;47911:7;;-1:-1:-1;;;;;47911:7:0;47897:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;47922:10;:21;47897:46;47889:67;;;;-1:-1:-1;;;47889:67:0;;;;;;;:::i;:::-;50156:12:::1;;50137:15;:31;;50129:40;;;::::0;::::1;;50180:8;:20:::0;50051:157::o;48617:276::-;48664:7;48688:13;45913:12;;;45842:91;48688:13;48705:1;48688:18;48684:78;;-1:-1:-1;48730:20:0;;;48617:276::o;48684:78::-;45913:12;;48851:10;;48833:14;;48804:26;:24;:26::i;:::-;:43;;;;:::i;:::-;48803:58;;;;:::i;:::-;:65;;48864:4;48803:65;:::i;:::-;:81;;;;:::i;:::-;48779:20;;:106;;;;:::i;52113:201::-;47911:7;;-1:-1:-1;;;;;47911:7:0;47897:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;47922:10;:21;47897:46;47889:67;;;;-1:-1:-1;;;47889:67:0;;;;;;;:::i;:::-;52208:39:::1;::::0;-1:-1:-1;;;52208:39:0;;52241:4:::1;52208:39;::::0;::::1;1822:51:1::0;52191:14:0::1;::::0;-1:-1:-1;;;;;52208:24:0;::::1;::::0;::::1;::::0;1795:18:1;;52208:39:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52191:56;;52258:48;52279:6;52287:10;52299:6;52258:20;:48::i;49608:97::-:0;49663:10;45998:7;46025:18;;;:9;:18;;;;;;49644:31;;49388:212;:::i;49644:31::-;49686:11;:9;:11::i;50351:100::-;47911:7;;-1:-1:-1;;;;;47911:7:0;47897:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;47922:10;:21;47897:46;47889:67;;;;-1:-1:-1;;;47889:67:0;;;;;;;:::i;:::-;50423:8:::1;:20:::0;;-1:-1:-1;;;;;;50423:20:0::1;-1:-1:-1::0;;;;;50423:20:0;;;::::1;::::0;;;::::1;::::0;;50351:100::o;29110:201::-;28090:13;:11;:13::i;:::-;-1:-1:-1;;;;;29199:22:0;::::1;29191:73;;;::::0;-1:-1:-1;;;29191:73:0;;5787:2:1;29191:73:0::1;::::0;::::1;5769:21:1::0;5826:2;5806:18;;;5799:30;5865:34;5845:18;;;5838:62;-1:-1:-1;;;5916:18:1;;;5909:36;5962:19;;29191:73:0::1;5585:402:1::0;29191:73:0::1;29275:28;29294:8;29275:18;:28::i;52322:263::-:0;47911:7;;-1:-1:-1;;;;;47911:7:0;47897:10;:21;;:46;;-1:-1:-1;28277:6:0;;-1:-1:-1;;;;;28277:6:0;47922:10;:21;47897:46;47889:67;;;;-1:-1:-1;;;47889:67:0;;;;;;;:::i;:::-;45913:12;;52429:18;52425:101:::1;;52490:11;::::0;-1:-1:-1;;;;;52490:11:0;;;::::1;::::0;::::1;52472:30:::0;;::::1;::::0;52464:50:::1;;;::::0;-1:-1:-1;;;52464:50:0;;6194:2:1;52464:50:0::1;::::0;::::1;6176:21:1::0;6233:1;6213:18;;;6206:29;-1:-1:-1;;;6251:18:1;;;6244:37;6298:18;;52464:50:0::1;5992:330:1::0;52464:50:0::1;52536:41;-1:-1:-1::0;;;;;52536:27:0;::::1;52564:3:::0;52569:7;52536:27:::1;:41::i;50771:784::-:0;50834:1;48213:16;:14;:16::i;:::-;48190:20;:39;48257:26;:24;:26::i;:::-;48240:14;:43;-1:-1:-1;;;;;48298:21:0;;;48294:157;;48355:15;48362:7;48355:6;:15::i;:::-;-1:-1:-1;;;;;48336:16:0;;;;;;:7;:16;;;;;;;;:34;;;;48419:20;;48385:22;:31;;;;;;:54;48294:157;50849:11:::1;50886:5;50872:11;;50863:6;:20;;;;:::i;:::-;:28;;;;:::i;:::-;50849:42:::0;-1:-1:-1;50906:7:0;;50902:107:::1;;50955:8;::::0;50930:11:::1;::::0;:39:::1;::::0;-1:-1:-1;;;;;50930:11:0;;::::1;::::0;50955:8:::1;50965:3:::0;50930:24:::1;:39::i;:::-;50984:13;50994:3:::0;50984:13;::::1;:::i;:::-;;;50902:107;51027:6;51037:1;51027:11:::0;51019:34:::1;;;::::0;-1:-1:-1;;;51019:34:0;;6529:2:1;51019:34:0::1;::::0;::::1;6511:21:1::0;6568:2;6548:18;;;6541:30;-1:-1:-1;;;6587:18:1;;;6580:40;6637:18;;51019:34:0::1;6327:334:1::0;51019:34:0::1;51087:12;;51068:15;:31;51064:291;;51138:8;::::0;51129:17:::1;::::0;:6;:17:::1;:::i;:::-;51116:10;:30:::0;51064:291:::1;;;51179:17;51214:15;51199:12;;:30;;;;:::i;:::-;51179:50;;51244:16;51275:10;;51263:9;:22;;;;:::i;:::-;51335:8;::::0;51244:41;;-1:-1:-1;51314:17:0::1;51244:41:::0;51314:6;:17:::1;:::i;:::-;51313:30;;;;:::i;:::-;51300:10;:43:::0;-1:-1:-1;;51064:291:0::1;51382:15;51365:14;:32:::0;;;51441:8:::1;::::0;51423:26:::1;::::0;::::1;:::i;:::-;51408:12;:41;;;;51477:6;51460:13;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;51494:10:0::1;:18:::0;;-1:-1:-1;;51494:18:0::1;::::0;;51528:19:::1;::::0;529:25:1;;;51528:19:0::1;::::0;517:2:1;502:18;51528:19:0::1;;;;;;;50838:717;50771:784:::0;;:::o;46270:187::-;46346:6;46330:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;46373:10:0;46363:21;;;;:9;:21;;;;;:31;;46388:6;;46363:21;:31;;46388:6;;46363:31;:::i;:::-;;;;-1:-1:-1;;46405:11:0;;:44;;:11;;;-1:-1:-1;;;;;46405:11:0;46430:10;46442:6;46405:24;:44::i;45702:132::-;24594:13;;;;;;;24586:69;;;;-1:-1:-1;;;24586:69:0;;;;;;;:::i;:::-;45792:11:::1;:34:::0;;-1:-1:-1;;;;;45792:34:0;;::::1;::::0;::::1;-1:-1:-1::0;;;;;;45792:34:0;;::::1;::::0;;;::::1;::::0;;45702:132::o;27747:97::-;24594:13;;;;;;;24586:69;;;;-1:-1:-1;;;24586:69:0;;;;;;;:::i;:::-;27810:26:::1;:24;:26::i;41597:211::-:0;41741:58;;-1:-1:-1;;;;;7270:32:1;;41741:58:0;;;7252:51:1;7319:18;;;7312:34;;;41714:86:0;;41734:5;;-1:-1:-1;;;41764:23:0;7225:18:1;;41741:58:0;;;;-1:-1:-1;;41741:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;41741:58:0;-1:-1:-1;;;;;;41741:58:0;;;;;;;;;;41714:19;:86::i;41816:248::-;41987:68;;-1:-1:-1;;;;;7615:15:1;;;41987:68:0;;;7597:34:1;7667:15;;7647:18;;;7640:43;7699:18;;;7692:34;;;41960:96:0;;41980:5;;-1:-1:-1;;;42010:27:0;7532:18:1;;41987:68:0;7357:375:1;41960:96:0;41816:248;;;;:::o;28369:132::-;28277:6;;-1:-1:-1;;;;;28277:6:0;26326:10;28433:23;28425:68;;;;-1:-1:-1;;;28425:68:0;;7939:2:1;28425:68:0;;;7921:21:1;;;7958:18;;;7951:30;8017:34;7997:18;;;7990:62;8069:18;;28425:68:0;7737:356:1;29471:191:0;29564:6;;;-1:-1:-1;;;;;29581:17:0;;;-1:-1:-1;;;;;;29581:17:0;;;;;;;29614:40;;29564:6;;;29581:17;29564:6;;29614:40;;29545:16;;29614:40;29534:128;29471:191;:::o;3518:106::-;3576:7;3607:1;3603;:5;:13;;3615:1;3603:13;;;3611:1;3603:13;3596:20;3518:106;-1:-1:-1;;;3518:106:0:o;46059:203::-;46132:6;46116:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;46159:10:0;46149:21;;;;:9;:21;;;;;:31;;46174:6;;46149:21;:31;;46174:6;;46149:31;:::i;:::-;;;;-1:-1:-1;;46191:11:0;;:63;;:11;;;-1:-1:-1;;;;;46191:11:0;46220:10;46240:4;46247:6;46191:28;:63::i;27852:113::-;24594:13;;;;;;;24586:69;;;;-1:-1:-1;;;24586:69:0;;;;;;;:::i;:::-;27925:32:::1;26326:10:::0;27925:18:::1;:32::i;44664:716::-:0;45088:23;45114:69;45142:4;45114:69;;;;;;;;;;;;;;;;;45122:5;-1:-1:-1;;;;;45114:27:0;;;:69;;;;;:::i;:::-;45198:17;;45088:95;;-1:-1:-1;45198:21:0;45194:179;;45295:10;45284:30;;;;;;;;;;;;:::i;:::-;45276:85;;;;-1:-1:-1;;;45276:85:0;;8550:2:1;45276:85:0;;;8532:21:1;8589:2;8569:18;;;8562:30;8628:34;8608:18;;;8601:62;-1:-1:-1;;;8679:18:1;;;8672:40;8729:19;;45276:85:0;8348:406:1;36310:229:0;36447:12;36479:52;36501:6;36509:4;36515:1;36518:12;36479:21;:52::i;:::-;36472:59;36310:229;-1:-1:-1;;;;36310:229:0:o;37430:510::-;37600:12;37658:5;37633:21;:30;;37625:81;;;;-1:-1:-1;;;37625:81:0;;8961:2:1;37625:81:0;;;8943:21:1;9000:2;8980:18;;;8973:30;9039:34;9019:18;;;9012:62;-1:-1:-1;;;9090:18:1;;;9083:36;9136:19;;37625:81:0;8759:402:1;37625:81:0;-1:-1:-1;;;;;13519:19:0;;;37717:60;;;;-1:-1:-1;;;37717:60:0;;9368:2:1;37717:60:0;;;9350:21:1;9407:2;9387:18;;;9380:30;9446:31;9426:18;;;9419:59;9495:18;;37717:60:0;9166:353:1;37717:60:0;37791:12;37805:23;37832:6;-1:-1:-1;;;;;37832:11:0;37851:5;37858:4;37832:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37790:73;;;;37881:51;37898:7;37907:10;37919:12;37881:16;:51::i;:::-;37874:58;37430:510;-1:-1:-1;;;;;;;37430:510:0:o;40116:762::-;40266:12;40295:7;40291:580;;;-1:-1:-1;40326:10:0;40319:17;;40291:580;40440:17;;:21;40436:424;;40688:10;40682:17;40749:15;40736:10;40732:2;40728:19;40721:44;40436:424;40831:12;40824:20;;-1:-1:-1;;;40824:20:0;;;;;;;;:::i;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;565:180::-;624:6;677:2;665:9;656:7;652:23;648:32;645:52;;;693:1;690;683:12;645:52;-1:-1:-1;716:23:1;;565:180;-1:-1:-1;565:180:1:o;750:118::-;836:5;829:13;822:21;815:5;812:32;802:60;;858:1;855;848:12;873:315;938:6;946;999:2;987:9;978:7;974:23;970:32;967:52;;;1015:1;1012;1005:12;967:52;1038:29;1057:9;1038:29;:::i;:::-;1028:39;;1117:2;1106:9;1102:18;1089:32;1130:28;1152:5;1130:28;:::i;:::-;1177:5;1167:15;;;873:315;;;;;:::o;1193:478::-;1288:6;1296;1304;1312;1320;1373:3;1361:9;1352:7;1348:23;1344:33;1341:53;;;1390:1;1387;1380:12;1341:53;1413:29;1432:9;1413:29;:::i;:::-;1403:39;;1461:38;1495:2;1484:9;1480:18;1461:38;:::i;:::-;1451:48;;1546:2;1535:9;1531:18;1518:32;1508:42;;1569:38;1603:2;1592:9;1588:18;1569:38;:::i;:::-;1559:48;;1626:39;1660:3;1649:9;1645:19;1626:39;:::i;:::-;1616:49;;1193:478;;;;;;;;:::o;2297:328::-;2374:6;2382;2390;2443:2;2431:9;2422:7;2418:23;2414:32;2411:52;;;2459:1;2456;2449:12;2411:52;2482:29;2501:9;2482:29;:::i;:::-;2472:39;;2530:38;2564:2;2553:9;2549:18;2530:38;:::i;:::-;2520:48;;2615:2;2604:9;2600:18;2587:32;2577:42;;2297:328;;;;;:::o;2630:127::-;2691:10;2686:3;2682:20;2679:1;2672:31;2722:4;2719:1;2712:15;2746:4;2743:1;2736:15;2762:125;2802:4;2830:1;2827;2824:8;2821:34;;;2835:18;;:::i;:::-;-1:-1:-1;2872:9:1;;2762:125::o;2892:168::-;2932:7;2998:1;2994;2990:6;2986:14;2983:1;2980:21;2975:1;2968:9;2961:17;2957:45;2954:71;;;3005:18;;:::i;:::-;-1:-1:-1;3045:9:1;;2892:168::o;3065:217::-;3105:1;3131;3121:132;;3175:10;3170:3;3166:20;3163:1;3156:31;3210:4;3207:1;3200:15;3238:4;3235:1;3228:15;3121:132;-1:-1:-1;3267:9:1;;3065:217::o;3287:128::-;3327:3;3358:1;3354:6;3351:1;3348:13;3345:39;;;3364:18;;:::i;:::-;-1:-1:-1;3400:9:1;;3287:128::o;3757:184::-;3827:6;3880:2;3868:9;3859:7;3855:23;3851:32;3848:52;;;3896:1;3893;3886:12;3848:52;-1:-1:-1;3919:16:1;;3757:184;-1:-1:-1;3757:184:1:o;4292:331::-;4494:2;4476:21;;;4533:1;4513:18;;;4506:29;-1:-1:-1;;;4566:2:1;4551:18;;4544:38;4614:2;4599:18;;4292:331::o;6666:407::-;6868:2;6850:21;;;6907:2;6887:18;;;6880:30;6946:34;6941:2;6926:18;;6919:62;-1:-1:-1;;;7012:2:1;6997:18;;6990:41;7063:3;7048:19;;6666:407::o;8098:245::-;8165:6;8218:2;8206:9;8197:7;8193:23;8189:32;8186:52;;;8234:1;8231;8224:12;8186:52;8266:9;8260:16;8285:28;8307:5;8285:28;:::i;9524:258::-;9596:1;9606:113;9620:6;9617:1;9614:13;9606:113;;;9696:11;;;9690:18;9677:11;;;9670:39;9642:2;9635:10;9606:113;;;9737:6;9734:1;9731:13;9728:48;;;-1:-1:-1;;9772:1:1;9754:16;;9747:27;9524:258::o;9787:274::-;9916:3;9954:6;9948:13;9970:53;10016:6;10011:3;10004:4;9996:6;9992:17;9970:53;:::i;:::-;10039:16;;;;;9787:274;-1:-1:-1;;9787:274:1:o;10066:383::-;10215:2;10204:9;10197:21;10178:4;10247:6;10241:13;10290:6;10285:2;10274:9;10270:18;10263:34;10306:66;10365:6;10360:2;10349:9;10345:18;10340:2;10332:6;10328:15;10306:66;:::i;:::-;10433:2;10412:15;-1:-1:-1;;10408:29:1;10393:45;;;;10440:2;10389:54;;10066:383;-1:-1:-1;;10066:383:1:o

ipfs://45885ef9f257d134b0171ce16517106c6fa73428474f4dab903ff9253d4701e6