Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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(
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
• library SafeCast
•    - function toUint224(uint256 value)
•    - function toUint128(uint256 value)
•    - function toUint96(uint256 value)
•    - function toUint64(uint256 value)
•    - function toUint32(uint256 value)
•    - function toUint16(uint256 value)
•    - function toUint8(uint256 value)
•    - function toUint256(int256 value)
•    - function toInt128(int256 value)
•    - function toInt64(int256 value)
•    - function toInt32(int256 value)
•    - function toInt16(int256 value)
•    - function toInt8(int256 value)
•    - function toInt256(uint256 value)
• library SignedSafeMath
•    - function mul(int256 a, int256 b)
•    - function div(int256 a, int256 b)
•    - function sub(int256 a, int256 b)
•    - function add(int256 a, int256 b)
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
•    - function __Context_init()
•    - function __Context_init_unchained()
•    - function _msgSender()
•    - function _msgData()
•    - function __Ownable_init()
•    - function __Ownable_init_unchained()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _setOwner(address newOwner)
•  contract Staking is Initializable, ... *
•    - function initialize(IERC20 _reward, I ...
•    - function setRewardPerBlock(uint256 _r ...
•    - function pendingReward(address _user)
•    - function updatePool()
•    - function deposit(uint256 amount, addr ...
•    - function withdraw(uint256 amount, add ...
•    - function harvest(address to)
•    - function emergencyWithdraw(address to ...
•    - function depositReward(uint256 amount ...
•    - function withdrawReward(uint256 amoun ...
•    - function updateVestingTime(uint256 pr ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-05-24
*/

pragma solidity ^0.8.0;

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

    /**
     * @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

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

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



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);
}

// File: @openzeppelin/contracts/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));
        }
    }

    /**
     * @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: @openzeppelin/contracts/utils/math/SafeCast.sol



pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

// File: @openzeppelin/contracts/utils/math/SignedSafeMath.sol



pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SignedSafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SignedSafeMath {
    /**
     * @dev Returns the multiplication of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        return a * b;
    }

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

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

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

// File: @openzeppelin/contracts/utils/math/SafeMath.sol



pragma solidity ^0.8.0;

// 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: @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol



pragma solidity ^0.8.0;

/**
 * @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 a proxied contract can't have 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.
 *
 * 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.
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

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

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}

// File: @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.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 initializer {
        __Context_init_unchained();
    }

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

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
    uint256[50] private __gap;
}

// File: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.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 initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {
        _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);
    }
    uint256[49] private __gap;
}

// File: Farm.sol

pragma solidity 0.8.0;
pragma experimental ABIEncoderV2;

contract Staking is Initializable, OwnableUpgradeable {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    using SignedSafeMath for int256;
    using SafeCast for int256;

    /// @notice Info of each user.
    /// `amount` LP token amount the user has provided.
    /// `rewardDebt` The amount of reward entitled to the user.
    /// `lastDepositedAt` The timestamp of the last deposit.
    struct UserInfo {
        uint256 amount;
        int256 rewardDebt;
        uint256 lastDepositedAt;
    }

    uint256 private constant ACC_REWARD_PRECISION = 1e12;

    /// @notice Address of reward contract.
    IERC20 public reward;

    /// @notice Address of the LP token.
    IERC20 public lpToken;

    /// @notice reward amount allocated per LP token.
    uint256 public accRewardPerShare;

    /// @notice Last block that the reward is calculated.
    uint256 public lastRewardBlock;

    /// @notice reward Per Block.
    uint256 public rewardPerBlock;

    // @notice vesting time required before allow to withdraw.
    uint256 public vestingTime = 30 days;

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

    event Deposit(address indexed user, uint256 amount, address indexed to);
    event Withdraw(address indexed user, uint256 amount, address indexed to);
    event EmergencyWithdraw(
        address indexed user,
        uint256 amount,
        address indexed to
    );
    event Harvest(address indexed user, uint256 amount);

    event LogUpdatePool(
        uint256 lastRewardBlock,
        uint256 lpSupply,
        uint256 accRewardPerShare
    );

    /**
     * @param _reward The reward token contract address.
     * @param _lpToken The staking contract address.
     */
    function initialize(IERC20 _reward, IERC20 _lpToken) external initializer {
        __Ownable_init();

        reward = _reward;
        lpToken = _lpToken;
        accRewardPerShare = 0;
        lastRewardBlock = block.number;
    }

    /**
     * @notice Sets the reward per block to be distributed. Can only be called by the owner.
     * @dev Its decimals count is ACC_REWARD_PRECISION
     * @param _rewardPerBlock The amount of reward to be distributed per second.
     */
    function setRewardPerBlock(uint256 _rewardPerBlock) public onlyOwner {
        updatePool();
        rewardPerBlock = _rewardPerBlock;
    }

    /**
     * @notice View function to see pending reward on frontend.
     * @dev It doens't update accRewardPerShare, it's just a view function.
     * @param _user Address of user.
     * @return pending reward for a given user.
     */
    function pendingReward(address _user)
        external
        view
        returns (uint256 pending)
    {
        UserInfo storage user = userInfo[_user];
        uint256 lpSupply = lpToken.balanceOf(address(this));
        uint256 accRewardPerShare_ = accRewardPerShare;

        if (block.number > lastRewardBlock && lpSupply != 0) {
            uint256 blocks = block.number.sub(lastRewardBlock);
            uint256 blockReward = blocks.mul(rewardPerBlock);
            accRewardPerShare_ = accRewardPerShare_.add(
                blockReward.mul(ACC_REWARD_PRECISION) / lpSupply
            );
        }
        pending = int256(
            user.amount.mul(accRewardPerShare_) / ACC_REWARD_PRECISION
        ).sub(user.rewardDebt).toUint256();
    }

    /**
     * @notice Update reward variables.
     * @dev Updates accRewardPerShare and lastRewardBlock.
     */
    function updatePool() public {
        if (block.number > lastRewardBlock) {
            uint256 lpSupply = lpToken.balanceOf(address(this));
            if (lpSupply > 0) {
                uint256 blocks = block.number.sub(lastRewardBlock);
                uint256 blockReward = blocks.mul(rewardPerBlock);
                accRewardPerShare = accRewardPerShare.add(
                    blockReward.mul(ACC_REWARD_PRECISION) / lpSupply
                );
            }
            lastRewardBlock = block.number;
            emit LogUpdatePool(lastRewardBlock, lpSupply, accRewardPerShare);
        }
    }

    /**
     * @notice Deposit LP tokens for reward allocation.
     * @param amount LP token amount to deposit.
     * @param to The receiver of `amount` deposit benefit.
     */
    function deposit(uint256 amount, address to) public {
        updatePool();
        UserInfo storage user = userInfo[to];

        // Effects
        user.lastDepositedAt = block.timestamp;
        user.amount = user.amount.add(amount);
        user.rewardDebt = user.rewardDebt.add(
            int256(amount.mul(accRewardPerShare) / ACC_REWARD_PRECISION)
        );

        lpToken.safeTransferFrom(msg.sender, address(this), amount);

        emit Deposit(msg.sender, amount, to);
    }

    /**
     * @notice Withdraw LP tokens and harvest rewards to `to`.
     * @param amount LP token amount to withdraw.
     * @param to Receiver of the LP tokens and rewards.
     */
    function withdraw(uint256 amount, address to) public {
        updatePool();
        UserInfo storage user = userInfo[msg.sender];
        require(block.timestamp >= user.lastDepositedAt.add(vestingTime), "Vesting time requires!");
        int256 accumulatedReward = int256(
            user.amount.mul(accRewardPerShare) / ACC_REWARD_PRECISION
        );
        uint256 _pendingReward = accumulatedReward
            .sub(user.rewardDebt)
            .toUint256();

        // Effects
        user.rewardDebt = accumulatedReward.sub(
            int256(amount.mul(accRewardPerShare) / ACC_REWARD_PRECISION)
        );
        user.amount = user.amount.sub(amount);

        reward.safeTransfer(to, _pendingReward);
        lpToken.safeTransfer(to, amount);

        emit Withdraw(msg.sender, amount, to);
        emit Harvest(msg.sender, _pendingReward);
    }

    /**
     * @notice Harvest rewards and send to `to`.
     * @dev Here comes the formula to calculate reward token amount
     * @param to Receiver of rewards.
     */
    function harvest(address to) public {
        updatePool();
        UserInfo storage user = userInfo[msg.sender];
        int256 accumulatedReward = int256(
            user.amount.mul(accRewardPerShare) / ACC_REWARD_PRECISION
        );
        uint256 _pendingReward = accumulatedReward
            .sub(user.rewardDebt)
            .toUint256();

        // Effects
        user.rewardDebt = accumulatedReward;

        // Interactions
        if (_pendingReward != 0) {
            reward.safeTransfer(to, _pendingReward);
        }

        emit Harvest(msg.sender, _pendingReward);
    }

    /**
     * @notice Withdraw without caring about rewards. EMERGENCY ONLY.
     * @param to Receiver of the LP tokens.
     */
    function emergencyWithdraw(address to) public {
        UserInfo storage user = userInfo[msg.sender];
        require(block.timestamp >= user.lastDepositedAt.add(vestingTime), "Vesting time requires!");
        uint256 amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;

        // Note: transfer can fail or succeed if `amount` is zero.
        lpToken.safeTransfer(to, amount);
        emit EmergencyWithdraw(msg.sender, amount, to);
    }

    /**
     * @notice deposit reward
     * @param amount to deposit
     */
    function depositReward(uint256 amount) external onlyOwner {
        reward.safeTransferFrom(msg.sender, address(this), amount);
    }

    /**
     * @notice withdraw reward
     * @param amount to withdraw
     */
    function withdrawReward(uint256 amount) external onlyOwner {
        reward.safeTransfer(msg.sender, amount);
    }

    function updateVestingTime(uint256 priodInSecond) external onlyOwner {
        vestingTime = priodInSecond;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lpSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accRewardPerShare","type":"uint256"}],"name":"LogUpdatePool","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":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"accRewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_reward","type":"address"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastRewardBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"pendingReward","outputs":[{"internalType":"uint256","name":"pending","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reward","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardPerBlock","type":"uint256"}],"name":"setRewardPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"priodInSecond","type":"uint256"}],"name":"updateVestingTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"int256","name":"rewardDebt","type":"int256"},{"internalType":"uint256","name":"lastDepositedAt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawReward","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

37109:8006:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42255:884;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43323:612;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;38288:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;44643:135;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37753:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38942:240;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44870:117;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37824:21;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41553:504;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44077:476;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;36366:94;;;:::i;:::-;;38083:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35715:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37909:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38009:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39440:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;38185:36;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44995:115;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40741:619;;;:::i;:::-;;36615:192;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39838:776;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42255:884;42319:12;:10;:12::i;:::-;42342:21;42366:8;:20;42375:10;42366:20;;;;;;;;;;;;;;;42342:44;;42424:37;42449:11;;42424:4;:20;;;:24;;:37;;;;:::i;:::-;42405:15;:56;;42397:91;;;;;;;;;;;;:::i;:::-;;;;;;;;;42499:24;37695:4;42547:34;42563:17;;42547:4;:11;;;:15;;:34;;;;:::i;:::-;:57;;;;:::i;:::-;42499:116;;42626:22;42651:78;:52;42687:4;:15;;;42651:17;:35;;:52;;;;:::i;:::-;:76;:78::i;:::-;42626:103;;42780:107;37695:4;42823:29;42834:17;;42823:6;:10;;:29;;;;:::i;:::-;:52;;;;:::i;:::-;42780:17;:21;;:107;;;;:::i;:::-;42762:4;:15;;:125;;;;42912:23;42928:6;42912:4;:11;;;:15;;:23;;;;:::i;:::-;42898:4;:11;;:37;;;;42948:39;42968:2;42972:14;42948:6;;;;;;;;;;;:19;;;;:39;;;;;:::i;:::-;42998:32;43019:2;43023:6;42998:7;;;;;;;;;;;:20;;;;:32;;;;;:::i;:::-;43077:2;43048:32;;43057:10;43048:32;;;43069:6;43048:32;;;;;;:::i;:::-;;;;;;;;43104:10;43096:35;;;43116:14;43096:35;;;;;;:::i;:::-;;;;;;;;42255:884;;;;;:::o;43323:612::-;43370:12;:10;:12::i;:::-;43393:21;43417:8;:20;43426:10;43417:20;;;;;;;;;;;;;;;43393:44;;43448:24;37695:4;43496:34;43512:17;;43496:4;:11;;;:15;;:34;;;;:::i;:::-;:57;;;;:::i;:::-;43448:116;;43575:22;43600:78;:52;43636:4;:15;;;43600:17;:35;;:52;;;;:::i;:::-;:76;:78::i;:::-;43575:103;;43729:17;43711:4;:15;;:35;;;;43806:1;43788:14;:19;43784:91;;43824:39;43844:2;43848:14;43824:6;;;;;;;;;;;:19;;;;:39;;;;;:::i;:::-;43784:91;43900:10;43892:35;;;43912:14;43892:35;;;;;;:::i;:::-;;;;;;;;43323:612;;;;:::o;38288:44::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;44643:135::-;35946:12;:10;:12::i;:::-;35935:23;;:7;:5;:7::i;:::-;:23;;;35927:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;44712:58:::1;44736:10;44756:4;44763:6;44712;;;;;;;;;;;:23;;;;:58;;;;;;:::i;:::-;44643:135:::0;:::o;37753:20::-;;;;;;;;;;;;;:::o;38942:240::-;33030:13;;;;;;;;;;;:30;;;;33048:12;;;;;;;;;;33047:13;33030:30;33022:89;;;;;;;;;;;;:::i;:::-;;;;;;;;;33124:19;33147:13;;;;;;;;;;;33146:14;33124:36;;33175:14;33171:101;;;33222:4;33206:13;;:20;;;;;;;;;;;;;;;;;;33256:4;33241:12;;:19;;;;;;;;;;;;;;;;;;33171:101;39027:16:::1;:14;:16::i;:::-;39065:7;39056:6;;:16;;;;;;;;;;;;;;;;;;39093:8;39083:7;;:18;;;;;;;;;;;;;;;;;;39132:1;39112:17;:21;;;;39162:12;39144:15;:30;;;;33302:14:::0;33298:68;;;33349:5;33333:13;;:21;;;;;;;;;;;;;;;;;;33298:68;38942:240;;;:::o;44870:117::-;35946:12;:10;:12::i;:::-;35935:23;;:7;:5;:7::i;:::-;:23;;;35927:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;44940:39:::1;44960:10;44972:6;44940;;;;;;;;;;;:19;;;;:39;;;;;:::i;:::-;44870:117:::0;:::o;37824:21::-;;;;;;;;;;;;;:::o;41553:504::-;41616:12;:10;:12::i;:::-;41639:21;41663:8;:12;41672:2;41663:12;;;;;;;;;;;;;;;41639:36;;41731:15;41708:4;:20;;:38;;;;41771:23;41787:6;41771:4;:11;;;:15;;:23;;;;:::i;:::-;41757:4;:11;;:37;;;;41823:105;37695:4;41864:29;41875:17;;41864:6;:10;;:29;;;;:::i;:::-;:52;;;;:::i;:::-;41823:4;:15;;;:19;;:105;;;;:::i;:::-;41805:4;:15;;:123;;;;41941:59;41966:10;41986:4;41993:6;41941:7;;;;;;;;;;;:24;;;;:59;;;;;;:::i;:::-;42046:2;42018:31;;42026:10;42018:31;;;42038:6;42018:31;;;;;;:::i;:::-;;;;;;;;41553:504;;;:::o;44077:476::-;44134:21;44158:8;:20;44167:10;44158:20;;;;;;;;;;;;;;;44134:44;;44216:37;44241:11;;44216:4;:20;;;:24;;:37;;;;:::i;:::-;44197:15;:56;;44189:91;;;;;;;;;;;;:::i;:::-;;;;;;;;;44291:14;44308:4;:11;;;44291:28;;44344:1;44330:4;:11;;:15;;;;44374:1;44356:4;:15;;:19;;;;44456:32;44477:2;44481:6;44456:7;;;;;;;;;;;:20;;;;:32;;;;;:::i;:::-;44542:2;44504:41;;44522:10;44504:41;;;44534:6;44504:41;;;;;;:::i;:::-;;;;;;;;44077:476;;;:::o;36366:94::-;35946:12;:10;:12::i;:::-;35935:23;;:7;:5;:7::i;:::-;:23;;;35927:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;36431:21:::1;36449:1;36431:9;:21::i;:::-;36366:94::o:0;38083:29::-;;;;:::o;35715:87::-;35761:7;35788:6;;;;;;;;;;;35781:13;;35715:87;:::o;37909:32::-;;;;:::o;38009:30::-;;;;:::o;39440:143::-;35946:12;:10;:12::i;:::-;35935:23;;:7;:5;:7::i;:::-;:23;;;35927:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;39520:12:::1;:10;:12::i;:::-;39560:15;39543:14;:32;;;;39440:143:::0;:::o;38185:36::-;;;;:::o;44995:115::-;35946:12;:10;:12::i;:::-;35935:23;;:7;:5;:7::i;:::-;:23;;;35927:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;45089:13:::1;45075:11;:27;;;;44995:115:::0;:::o;40741:619::-;40800:15;;40785:12;:30;40781:572;;;40832:16;40851:7;;;;;;;;;;;:17;;;40877:4;40851:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40832:51;;40913:1;40902:8;:12;40898:320;;;40935:14;40952:33;40969:15;;40952:12;:16;;:33;;;;:::i;:::-;40935:50;;41004:19;41026:26;41037:14;;41026:6;:10;;:26;;;;:::i;:::-;41004:48;;41091:111;41175:8;41135:37;37695:4;41135:11;:15;;:37;;;;:::i;:::-;:48;;;;:::i;:::-;41091:17;;:21;;:111;;;;:::i;:::-;41071:17;:131;;;;40898:320;;;41250:12;41232:15;:30;;;;41282:59;41296:15;;41313:8;41323:17;;41282:59;;;;;;;;:::i;:::-;;;;;;;;40781:572;;40741:619::o;36615:192::-;35946:12;:10;:12::i;:::-;35935:23;;:7;:5;:7::i;:::-;:23;;;35927:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;36724:1:::1;36704:22;;:8;:22;;;;36696:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;36780:19;36790:8;36780:9;:19::i;:::-;36615:192:::0;:::o;39838:776::-;39926:15;39959:21;39983:8;:15;39992:5;39983:15;;;;;;;;;;;;;;;39959:39;;40009:16;40028:7;;;;;;;;;;;:17;;;40054:4;40028:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40009:51;;40071:26;40100:17;;40071:46;;40149:15;;40134:12;:30;:47;;;;;40180:1;40168:8;:13;;40134:47;40130:333;;;40198:14;40215:33;40232:15;;40215:12;:16;;:33;;;;:::i;:::-;40198:50;;40263:19;40285:26;40296:14;;40285:6;:10;;:26;;;;:::i;:::-;40263:48;;40347:104;40428:8;40388:37;37695:4;40388:11;:15;;:37;;;;:::i;:::-;:48;;;;:::i;:::-;40347:18;:22;;:104;;;;:::i;:::-;40326:125;;40130:333;;;40483:123;:111;40578:4;:15;;;37695:4;40504:35;40520:18;40504:4;:11;;;:15;;:35;;;;:::i;:::-;:58;;;;:::i;:::-;40483:94;;:111;;;;:::i;:::-;:121;:123::i;:::-;40473:133;;39838:776;;;;;;:::o;27378:98::-;27436:7;27467:1;27463;:5;;;;:::i;:::-;27456:12;;27378:98;;;;:::o;28116:::-;28174:7;28205:1;28201;:5;;;;:::i;:::-;28194:12;;28116:98;;;;:::o;24144:95::-;24200:6;24230:1;24226;:5;;;;:::i;:::-;24219:12;;24144:95;;;;:::o;19246:171::-;19302:7;19339:1;19330:5;:10;;19322:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;19403:5;19388:21;;19246:171;;;:::o;27759:98::-;27817:7;27848:1;27844;:5;;;;:::i;:::-;27837:12;;27759:98;;;;:::o;11505:211::-;11622:86;11642:5;11672:23;;;11697:2;11701:5;11649:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11622:19;:86::i;:::-;11505:211;;;:::o;34229:98::-;34282:7;34309:10;34302:17;;34229:98;:::o;11724:248::-;11868:96;11888:5;11918:27;;;11947:4;11953:2;11957:5;11895:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11868:19;:96::i;:::-;11724:248;;;;:::o;35398:129::-;33030:13;;;;;;;;;;;:30;;;;33048:12;;;;;;;;;;33047:13;33030:30;33022:89;;;;;;;;;;;;:::i;:::-;;;;;;;;;33124:19;33147:13;;;;;;;;;;;33146:14;33124:36;;33175:14;33171:101;;;33222:4;33206:13;;:20;;;;;;;;;;;;;;;;;;33256:4;33241:12;;:19;;;;;;;;;;;;;;;;;;33171:101;35456:26:::1;:24;:26::i;:::-;35493;:24;:26::i;:::-;33302:14:::0;33298:68;;;33349:5;33333:13;;:21;;;;;;;;;;;;;;;;;;33298:68;35398:129;:::o;24484:95::-;24540:6;24570:1;24566;:5;;;;:::i;:::-;24559:12;;24484:95;;;;:::o;36815:173::-;36871:16;36890:6;;;;;;;;;;;36871:25;;36916:8;36907:6;;:17;;;;;;;;;;;;;;;;;;36971:8;36940:40;;36961:8;36940:40;;;;;;;;;;;;36815:173;;:::o;14078:716::-;14502:23;14528:69;14556:4;14528:69;;;;;;;;;;;;;;;;;14536:5;14528:27;;;;:69;;;;;:::i;:::-;14502:95;;14632:1;14612:10;:17;:21;14608:179;;;14709:10;14698:30;;;;;;;;;;;;:::i;:::-;14690:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;14608:179;14078:716;;;:::o;34158:65::-;33030:13;;;;;;;;;;;:30;;;;33048:12;;;;;;;;;;33047:13;33030:30;33022:89;;;;;;;;;;;;:::i;:::-;;;;;;;;;33124:19;33147:13;;;;;;;;;;;33146:14;33124:36;;33175:14;33171:101;;;33222:4;33206:13;;:20;;;;;;;;;;;;;;;;;;33256:4;33241:12;;:19;;;;;;;;;;;;;;;;;;33171:101;33302:14;33298:68;;;33349:5;33333:13;;:21;;;;;;;;;;;;;;;;;;33298:68;34158:65;:::o;35535:99::-;33030:13;;;;;;;;;;;:30;;;;33048:12;;;;;;;;;;33047:13;33030:30;33022:89;;;;;;;;;;;;:::i;:::-;;;;;;;;;33124:19;33147:13;;;;;;;;;;;33146:14;33124:36;;33175:14;33171:101;;;33222:4;33206:13;;:20;;;;;;;;;;;;;;;;;;33256:4;33241:12;;:19;;;;;;;;;;;;;;;;;;33171:101;35603:23:::1;35613:12;:10;:12::i;:::-;35603:9;:23::i;:::-;33302:14:::0;33298:68;;;33349:5;33333:13;;:21;;;;;;;;;;;;;;;;;;33298:68;35535:99;:::o;3514:229::-;3651:12;3683:52;3705:6;3713:4;3719:1;3722:12;3683:21;:52::i;:::-;3676:59;;3514:229;;;;;:::o;4634:510::-;4804:12;4862:5;4837:21;:30;;4829:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;4929:18;4940:6;4929:10;:18::i;:::-;4921:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;4995:12;5009:23;5036:6;:11;;5055:5;5062:4;5036:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4994:73;;;;5085:51;5102:7;5111:10;5123:12;5085:16;:51::i;:::-;5078:58;;;;4634:510;;;;;;:::o;708:387::-;768:4;976:12;1043:7;1031:20;1023:28;;1086:1;1079:4;:8;1072:15;;;708:387;;;:::o;7320:712::-;7470:12;7499:7;7495:530;;;7530:10;7523:17;;;;7495:530;7664:1;7644:10;:17;:21;7640:374;;;7842:10;7836:17;7903:15;7890:10;7886:2;7882:19;7875:44;7790:148;7985:12;7978:20;;;;;;;;;;;:::i;:::-;;;;;;;;7320:712;;;;;;:::o;7:139:1:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:137::-;;237:6;231:13;222:22;;253:30;277:5;253:30;:::i;:::-;212:77;;;;:::o;295:167::-;;393:6;380:20;371:29;;409:47;450:5;409:47;:::i;:::-;361:101;;;;:::o;468:139::-;;552:6;539:20;530:29;;568:33;595:5;568:33;:::i;:::-;520:87;;;;:::o;613:143::-;;701:6;695:13;686:22;;717:33;744:5;717:33;:::i;:::-;676:80;;;;:::o;762:262::-;;870:2;858:9;849:7;845:23;841:32;838:2;;;886:1;883;876:12;838:2;929:1;954:53;999:7;990:6;979:9;975:22;954:53;:::i;:::-;944:63;;900:117;828:196;;;;:::o;1030:278::-;;1146:2;1134:9;1125:7;1121:23;1117:32;1114:2;;;1162:1;1159;1152:12;1114:2;1205:1;1230:61;1283:7;1274:6;1263:9;1259:22;1230:61;:::i;:::-;1220:71;;1176:125;1104:204;;;;:::o;1314:463::-;;;1467:2;1455:9;1446:7;1442:23;1438:32;1435:2;;;1483:1;1480;1473:12;1435:2;1526:1;1551:67;1610:7;1601:6;1590:9;1586:22;1551:67;:::i;:::-;1541:77;;1497:131;1667:2;1693:67;1752:7;1743:6;1732:9;1728:22;1693:67;:::i;:::-;1683:77;;1638:132;1425:352;;;;;:::o;1783:262::-;;1891:2;1879:9;1870:7;1866:23;1862:32;1859:2;;;1907:1;1904;1897:12;1859:2;1950:1;1975:53;2020:7;2011:6;2000:9;1996:22;1975:53;:::i;:::-;1965:63;;1921:117;1849:196;;;;:::o;2051:284::-;;2170:2;2158:9;2149:7;2145:23;2141:32;2138:2;;;2186:1;2183;2176:12;2138:2;2229:1;2254:64;2310:7;2301:6;2290:9;2286:22;2254:64;:::i;:::-;2244:74;;2200:128;2128:207;;;;:::o;2341:407::-;;;2466:2;2454:9;2445:7;2441:23;2437:32;2434:2;;;2482:1;2479;2472:12;2434:2;2525:1;2550:53;2595:7;2586:6;2575:9;2571:22;2550:53;:::i;:::-;2540:63;;2496:117;2652:2;2678:53;2723:7;2714:6;2703:9;2699:22;2678:53;:::i;:::-;2668:63;;2623:118;2424:324;;;;;:::o;2754:118::-;2841:24;2859:5;2841:24;:::i;:::-;2836:3;2829:37;2819:53;;:::o;2878:373::-;;3010:38;3042:5;3010:38;:::i;:::-;3064:88;3145:6;3140:3;3064:88;:::i;:::-;3057:95;;3161:52;3206:6;3201:3;3194:4;3187:5;3183:16;3161:52;:::i;:::-;3238:6;3233:3;3229:16;3222:23;;2986:265;;;;;:::o;3257:159::-;3358:51;3403:5;3358:51;:::i;:::-;3353:3;3346:64;3336:80;;:::o;3422:115::-;3507:23;3524:5;3507:23;:::i;:::-;3502:3;3495:36;3485:52;;:::o;3543:364::-;;3659:39;3692:5;3659:39;:::i;:::-;3714:71;3778:6;3773:3;3714:71;:::i;:::-;3707:78;;3794:52;3839:6;3834:3;3827:4;3820:5;3816:16;3794:52;:::i;:::-;3871:29;3893:6;3871:29;:::i;:::-;3866:3;3862:39;3855:46;;3635:272;;;;;:::o;3913:320::-;;4076:67;4140:2;4135:3;4076:67;:::i;:::-;4069:74;;4173:24;4169:1;4164:3;4160:11;4153:45;4224:2;4219:3;4215:12;4208:19;;4059:174;;;:::o;4239:370::-;;4402:67;4466:2;4461:3;4402:67;:::i;:::-;4395:74;;4499:34;4495:1;4490:3;4486:11;4479:55;4565:8;4560:2;4555:3;4551:12;4544:30;4600:2;4595:3;4591:12;4584:19;;4385:224;;;:::o;4615:370::-;;4778:67;4842:2;4837:3;4778:67;:::i;:::-;4771:74;;4875:34;4871:1;4866:3;4862:11;4855:55;4941:8;4936:2;4931:3;4927:12;4920:30;4976:2;4971:3;4967:12;4960:19;;4761:224;;;:::o;4991:330::-;;5154:67;5218:2;5213:3;5154:67;:::i;:::-;5147:74;;5251:34;5247:1;5242:3;5238:11;5231:55;5312:2;5307:3;5303:12;5296:19;;5137:184;;;:::o;5327:378::-;;5490:67;5554:2;5549:3;5490:67;:::i;:::-;5483:74;;5587:34;5583:1;5578:3;5574:11;5567:55;5653:16;5648:2;5643:3;5639:12;5632:38;5696:2;5691:3;5687:12;5680:19;;5473:232;;;:::o;5711:330::-;;5874:67;5938:2;5933:3;5874:67;:::i;:::-;5867:74;;5971:34;5967:1;5962:3;5958:11;5951:55;6032:2;6027:3;6023:12;6016:19;;5857:184;;;:::o;6047:327::-;;6210:67;6274:2;6269:3;6210:67;:::i;:::-;6203:74;;6307:31;6303:1;6298:3;6294:11;6287:52;6365:2;6360:3;6356:12;6349:19;;6193:181;;;:::o;6380:374::-;;6543:67;6607:2;6602:3;6543:67;:::i;:::-;6536:74;;6640:34;6636:1;6631:3;6627:11;6620:55;6706:12;6701:2;6696:3;6692:12;6685:34;6745:2;6740:3;6736:12;6729:19;;6526:228;;;:::o;6760:118::-;6847:24;6865:5;6847:24;:::i;:::-;6842:3;6835:37;6825:53;;:::o;6884:271::-;;7036:93;7125:3;7116:6;7036:93;:::i;:::-;7029:100;;7146:3;7139:10;;7018:137;;;;:::o;7161:222::-;;7292:2;7281:9;7277:18;7269:26;;7305:71;7373:1;7362:9;7358:17;7349:6;7305:71;:::i;:::-;7259:124;;;;:::o;7389:442::-;;7576:2;7565:9;7561:18;7553:26;;7589:71;7657:1;7646:9;7642:17;7633:6;7589:71;:::i;:::-;7670:72;7738:2;7727:9;7723:18;7714:6;7670:72;:::i;:::-;7752;7820:2;7809:9;7805:18;7796:6;7752:72;:::i;:::-;7543:288;;;;;;:::o;7837:332::-;;7996:2;7985:9;7981:18;7973:26;;8009:71;8077:1;8066:9;8062:17;8053:6;8009:71;:::i;:::-;8090:72;8158:2;8147:9;8143:18;8134:6;8090:72;:::i;:::-;7963:206;;;;;:::o;8175:250::-;;8320:2;8309:9;8305:18;8297:26;;8333:85;8415:1;8404:9;8400:17;8391:6;8333:85;:::i;:::-;8287:138;;;;:::o;8431:313::-;;8582:2;8571:9;8567:18;8559:26;;8631:9;8625:4;8621:20;8617:1;8606:9;8602:17;8595:47;8659:78;8732:4;8723:6;8659:78;:::i;:::-;8651:86;;8549:195;;;;:::o;8750:419::-;;8954:2;8943:9;8939:18;8931:26;;9003:9;8997:4;8993:20;8989:1;8978:9;8974:17;8967:47;9031:131;9157:4;9031:131;:::i;:::-;9023:139;;8921:248;;;:::o;9175:419::-;;9379:2;9368:9;9364:18;9356:26;;9428:9;9422:4;9418:20;9414:1;9403:9;9399:17;9392:47;9456:131;9582:4;9456:131;:::i;:::-;9448:139;;9346:248;;;:::o;9600:419::-;;9804:2;9793:9;9789:18;9781:26;;9853:9;9847:4;9843:20;9839:1;9828:9;9824:17;9817:47;9881:131;10007:4;9881:131;:::i;:::-;9873:139;;9771:248;;;:::o;10025:419::-;;10229:2;10218:9;10214:18;10206:26;;10278:9;10272:4;10268:20;10264:1;10253:9;10249:17;10242:47;10306:131;10432:4;10306:131;:::i;:::-;10298:139;;10196:248;;;:::o;10450:419::-;;10654:2;10643:9;10639:18;10631:26;;10703:9;10697:4;10693:20;10689:1;10678:9;10674:17;10667:47;10731:131;10857:4;10731:131;:::i;:::-;10723:139;;10621:248;;;:::o;10875:419::-;;11079:2;11068:9;11064:18;11056:26;;11128:9;11122:4;11118:20;11114:1;11103:9;11099:17;11092:47;11156:131;11282:4;11156:131;:::i;:::-;11148:139;;11046:248;;;:::o;11300:419::-;;11504:2;11493:9;11489:18;11481:26;;11553:9;11547:4;11543:20;11539:1;11528:9;11524:17;11517:47;11581:131;11707:4;11581:131;:::i;:::-;11573:139;;11471:248;;;:::o;11725:419::-;;11929:2;11918:9;11914:18;11906:26;;11978:9;11972:4;11968:20;11964:1;11953:9;11949:17;11942:47;12006:131;12132:4;12006:131;:::i;:::-;11998:139;;11896:248;;;:::o;12150:222::-;;12281:2;12270:9;12266:18;12258:26;;12294:71;12362:1;12351:9;12347:17;12338:6;12294:71;:::i;:::-;12248:124;;;;:::o;12378:438::-;;12563:2;12552:9;12548:18;12540:26;;12576:71;12644:1;12633:9;12629:17;12620:6;12576:71;:::i;:::-;12657:70;12723:2;12712:9;12708:18;12699:6;12657:70;:::i;:::-;12737:72;12805:2;12794:9;12790:18;12781:6;12737:72;:::i;:::-;12530:286;;;;;;:::o;12822:442::-;;13009:2;12998:9;12994:18;12986:26;;13022:71;13090:1;13079:9;13075:17;13066:6;13022:71;:::i;:::-;13103:72;13171:2;13160:9;13156:18;13147:6;13103:72;:::i;:::-;13185;13253:2;13242:9;13238:18;13229:6;13185:72;:::i;:::-;12976:288;;;;;;:::o;13270:98::-;;13355:5;13349:12;13339:22;;13328:40;;;:::o;13374:99::-;;13460:5;13454:12;13444:22;;13433:40;;;:::o;13479:147::-;;13617:3;13602:18;;13592:34;;;;:::o;13632:169::-;;13750:6;13745:3;13738:19;13790:4;13785:3;13781:14;13766:29;;13728:73;;;;:::o;13807:525::-;;13865:19;13882:1;13865:19;:::i;:::-;13860:24;;13898:19;13915:1;13898:19;:::i;:::-;13893:24;;14086:1;14018:66;14014:74;14011:1;14007:82;14002:1;13999;13995:9;13988:17;13984:106;13981:2;;;14093:18;;:::i;:::-;13981:2;14273:1;14205:66;14201:74;14198:1;14194:82;14190:1;14187;14183:9;14179:98;14176:2;;;14280:18;;:::i;:::-;14176:2;14324:1;14321;14317:9;14310:16;;13850:482;;;;:::o;14338:305::-;;14397:20;14415:1;14397:20;:::i;:::-;14392:25;;14431:20;14449:1;14431:20;:::i;:::-;14426:25;;14585:1;14517:66;14513:74;14510:1;14507:81;14504:2;;;14591:18;;:::i;:::-;14504:2;14635:1;14632;14628:9;14621:16;;14382:261;;;;:::o;14649:185::-;;14706:20;14724:1;14706:20;:::i;:::-;14701:25;;14740:20;14758:1;14740:20;:::i;:::-;14735:25;;14779:1;14769:2;;14784:18;;:::i;:::-;14769:2;14826:1;14823;14819:9;14814:14;;14691:143;;;;:::o;14840:348::-;;14903:20;14921:1;14903:20;:::i;:::-;14898:25;;14937:20;14955:1;14937:20;:::i;:::-;14932:25;;15125:1;15057:66;15053:74;15050:1;15047:81;15042:1;15035:9;15028:17;15024:105;15021:2;;;15132:18;;:::i;:::-;15021:2;15180:1;15177;15173:9;15162:20;;14888:300;;;;:::o;15194:527::-;;15253:19;15270:1;15253:19;:::i;:::-;15248:24;;15286:19;15303:1;15286:19;:::i;:::-;15281:24;;15475:1;15407:66;15403:74;15400:1;15396:82;15391:1;15388;15384:9;15377:17;15373:106;15370:2;;;15482:18;;:::i;:::-;15370:2;15661:1;15593:66;15589:74;15586:1;15582:82;15578:1;15575;15571:9;15567:98;15564:2;;;15668:18;;:::i;:::-;15564:2;15713:1;15710;15706:9;15698:17;;15238:483;;;;:::o;15727:191::-;;15787:20;15805:1;15787:20;:::i;:::-;15782:25;;15821:20;15839:1;15821:20;:::i;:::-;15816:25;;15860:1;15857;15854:8;15851:2;;;15865:18;;:::i;:::-;15851:2;15910:1;15907;15903:9;15895:17;;15772:146;;;;:::o;15924:96::-;;15990:24;16008:5;15990:24;:::i;:::-;15979:35;;15969:51;;;:::o;16026:90::-;;16103:5;16096:13;16089:21;16078:32;;16068:48;;;:::o;16122:110::-;;16202:24;16220:5;16202:24;:::i;:::-;16191:35;;16181:51;;;:::o;16238:76::-;;16303:5;16292:16;;16282:32;;;:::o;16320:126::-;;16397:42;16390:5;16386:54;16375:65;;16365:81;;;:::o;16452:77::-;;16518:5;16507:16;;16497:32;;;:::o;16535:154::-;;16632:51;16677:5;16632:51;:::i;:::-;16619:64;;16609:80;;;:::o;16695:127::-;;16792:24;16810:5;16792:24;:::i;:::-;16779:37;;16769:53;;;:::o;16828:307::-;16896:1;16906:113;16920:6;16917:1;16914:13;16906:113;;;17005:1;17000:3;16996:11;16990:18;16986:1;16981:3;16977:11;16970:39;16942:2;16939:1;16935:10;16930:15;;16906:113;;;17037:6;17034:1;17031:13;17028:2;;;17117:1;17108:6;17103:3;17099:16;17092:27;17028:2;16877:258;;;;:::o;17141:180::-;17189:77;17186:1;17179:88;17286:4;17283:1;17276:15;17310:4;17307:1;17300:15;17327:180;17375:77;17372:1;17365:88;17472:4;17469:1;17462:15;17496:4;17493:1;17486:15;17513:102;;17605:2;17601:7;17596:2;17589:5;17585:14;17581:28;17571:38;;17561:54;;;:::o;17621:122::-;17694:24;17712:5;17694:24;:::i;:::-;17687:5;17684:35;17674:2;;17733:1;17730;17723:12;17674:2;17664:79;:::o;17749:116::-;17819:21;17834:5;17819:21;:::i;:::-;17812:5;17809:32;17799:2;;17855:1;17852;17845:12;17799:2;17789:76;:::o;17871:150::-;17958:38;17990:5;17958:38;:::i;:::-;17951:5;17948:49;17938:2;;18011:1;18008;18001:12;17938:2;17928:93;:::o;18027:122::-;18100:24;18118:5;18100:24;:::i;:::-;18093:5;18090:35;18080:2;;18139:1;18136;18129:12;18080:2;18070:79;:::o

ipfs://96c6b542862c90e8ee5d6170870c669db34dc1ca967ce9396978875c65083378