Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

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(address from, a ...
• 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(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
•    - function _reentrancyGuardEntered()
•  contract ShadowGenesisRewardPool i ... *
•    - function checkPoolDuplicate(IERC20 _t ...
•    - function add(
•    - function set(uint256 _pid, uint256 _a ...
•    - function getGeneratedReward(uint256 _ ...
•    - function pendingSHADOW(uint256 _pid, ...
•    - function massUpdatePools()
•    - function updatePool(uint256 _pid)
•    - function deposit(uint256 _pid, uint25 ...
•    - function withdraw(uint256 _pid, uint2 ...
•    - function emergencyWithdraw(uint256 _p ...
•    - function safeShadowTransfer(address _ ...
•    - function setFeeAddress(address _feeAd ...
•    - function setOperator(address _operato ...
•    - function governanceRecoverUnsupported ...

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at SonicScan.org on 2025-02-26
*/

// SPDX-License-Identifier: MIT


// OpenZeppelin Contracts (last updated v4.9.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);
}


// OpenZeppelin Contracts (last updated v4.9.0) (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 generally not needed starting with Solidity 0.8, since 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 subtraction 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/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.9.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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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



// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
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].
     *
     * CAUTION: See Security Considerations above.
     */
    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/contracts/token/ERC20/[email protected]


// OpenZeppelin Contracts (last updated v4.9.3) (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;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    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));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    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");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    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");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation 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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

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

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

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


// File contracts/distribution/ShadowGenesisRewardPool.sol



pragma solidity ^0.8.0;



// Note that this pool has no minter key of SHADOW (rewards).
// Instead, the governance will call SHADOW distributeReward method and send reward to this pool at the beginning.
contract ShadowGenesisRewardPool is ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // governance
    address public operator;
    address public feeAddress;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 token; // Address of LP token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool. SHADOW to distribute.
        uint256 lastRewardTime; // Last time that SHADOW distribution occurs.
        uint16  depositFeeBP; //depositfee
        uint256 accShadowPerShare; // Accumulated SHADOW per share, times 1e18. See below.
        bool isStarted; // if lastRewardBlock has passed
    }

    IERC20 public shadow;
    address public devFund;

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

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

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

    // The time when SHADOW mining starts.
    uint256 public poolStartTime;

    // The time when SHADOW mining ends.
    uint256 public poolEndTime;

    // TESTNET
    //uint256 public shadowPerSecond = 0.66667 ether; // 2400 SHADOW / (1h * 60min * 60s)
    //uint256 public runningTime = 1 hours; // 1 hours
    //uint256 public constant TOTAL_REWARDS = 2400 ether;
    // END TESTNET

    // MAINNET
    uint256 public shadowPerSecond = 0.138888888 ether; // 12000 SHADOW / (24h * 60min * 60s)
    uint256 public runningTime = 1 days; // 1 days
    uint256 public constant TOTAL_REWARDS = 12000 ether;
    // END MAINNET

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event SetFeeAddress(address indexed user, address indexed newAddress);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event RewardPaid(address indexed user, uint256 amount);

    constructor(
        address _shadow,
        address _devFund,
        address _feeAddress,
        uint256 _poolStartTime
    )  {
        require(block.timestamp < _poolStartTime, "late");
        if (_shadow != address(0)) shadow = IERC20(_shadow);
        if (_devFund != address(0)) devFund = _devFund;
        poolStartTime = _poolStartTime;
        poolEndTime = poolStartTime + runningTime;
        operator = msg.sender;
        feeAddress = _feeAddress;
    }

    modifier onlyOperator() {
        require(operator == msg.sender, "ShadowGenesisPool: caller is not the operator");
        _;
    }

    function checkPoolDuplicate(IERC20 _token) internal view {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            require(poolInfo[pid].token != _token, "ShadowGenesisPool: existing pool?");
        }
    }

    // Add a new token to the pool. Can only be called by the owner.
    function add(
        uint256 _allocPoint,
        IERC20 _token,
        bool _withUpdate,
        uint256 _lastRewardTime,
        uint16  _depositFeeBP

    ) public onlyOperator {
            require(_depositFeeBP <= 100, "add: invalid deposit fee basis points");

        checkPoolDuplicate(_token);
        if (_withUpdate) {
            massUpdatePools();
        }
        if (block.timestamp < poolStartTime) {
            // chef is sleeping
            if (_lastRewardTime == 0) {
                _lastRewardTime = poolStartTime;
            } else {
                if (_lastRewardTime < poolStartTime) {
                    _lastRewardTime = poolStartTime;
                }
            }
        } else {
            // chef is cooking
            if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
                _lastRewardTime = block.timestamp;
            }
        }
        bool _isStarted = (_lastRewardTime <= poolStartTime) || (_lastRewardTime <= block.timestamp);
        poolInfo.push(PoolInfo({token: _token, allocPoint: _allocPoint, lastRewardTime: _lastRewardTime, accShadowPerShare: 0, isStarted: _isStarted, depositFeeBP: _depositFeeBP}));
        if (_isStarted) {
            totalAllocPoint = totalAllocPoint.add(_allocPoint);
        }
    }

    // Update the given pool's SHADOW allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint,  uint16 _depositFeeBP) public onlyOperator {
            require(_depositFeeBP <= 100, "set: invalid deposit fee basis points");
        massUpdatePools();
        PoolInfo storage pool = poolInfo[_pid];
        if (pool.isStarted) {
            totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
        }
        pool.allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;

    }

    // Return accumulate rewards over the given _from to _to block.
    function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
        if (_fromTime >= _toTime) return 0;
        if (_toTime >= poolEndTime) {
            if (_fromTime >= poolEndTime) return 0;
            if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(shadowPerSecond);
            return poolEndTime.sub(_fromTime).mul(shadowPerSecond);
        } else {
            if (_toTime <= poolStartTime) return 0;
            if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(shadowPerSecond);
            return _toTime.sub(_fromTime).mul(shadowPerSecond);
        }
    }

    // View function to see pending SHADOW on frontend.
    function pendingSHADOW(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accShadowPerShare = pool.accShadowPerShare;
        uint256 tokenSupply = pool.token.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
            uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
            uint256 _shadowReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
            accShadowPerShare = accShadowPerShare.add(_shadowReward.mul(1e18).div(tokenSupply));
        }
        return user.amount.mul(accShadowPerShare).div(1e18).sub(user.rewardDebt);
    }

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

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }
        uint256 tokenSupply = pool.token.balanceOf(address(this));
        if (tokenSupply == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        if (!pool.isStarted) {
            pool.isStarted = true;
            totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
        }
        if (totalAllocPoint > 0) {
            uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
            uint256 _shadowReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
            pool.accShadowPerShare = pool.accShadowPerShare.add(_shadowReward.mul(1e18).div(tokenSupply));
        }
        pool.lastRewardTime = block.timestamp;
    }

    // Deposit LP tokens.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 _pending = user.amount.mul(pool.accShadowPerShare).div(1e18).sub(user.rewardDebt);
            if (_pending > 0) {
                safeShadowTransfer(_sender, _pending);
                emit RewardPaid(_sender, _pending);
            }
        }
        if (_amount > 0) {
            pool.token.safeTransferFrom(_sender, address(this), _amount);
            if (address(pool.token) == devFund) {
                user.amount = user.amount.add(_amount.mul(9900).div(10000));
           }
             if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.token.safeTransfer(feeAddress, depositFee);
                // pool.lpToken.safeTransfer(vaultAddress, depositFee);
                user.amount = user.amount.add(_amount).sub(depositFee);
             }
             else {
                user.amount = user.amount.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accShadowPerShare).div(1e18);
        emit Deposit(_sender, _pid, _amount);
    }

    // Withdraw LP tokens.
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 _pending = user.amount.mul(pool.accShadowPerShare).div(1e18).sub(user.rewardDebt);
        if (_pending > 0) {
            safeShadowTransfer(_sender, _pending);
            emit RewardPaid(_sender, _pending);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.token.safeTransfer(_sender, _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accShadowPerShare).div(1e18);
        emit Withdraw(_sender, _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 _amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;
        pool.token.safeTransfer(msg.sender, _amount);
        emit EmergencyWithdraw(msg.sender, _pid, _amount);
    }

    // Safe SHADOW transfer function, just in case a rounding error causes pool to not have enough SHADOWs.
    function safeShadowTransfer(address _to, uint256 _amount) internal {
        uint256 _shadowBalance = shadow.balanceOf(address(this));
        if (_shadowBalance > 0) {
            if (_amount > _shadowBalance) {
                shadow.safeTransfer(_to, _shadowBalance);
            } else {
                shadow.safeTransfer(_to, _amount);
            }
        }
    }
    function setFeeAddress(address _feeAddress) external onlyOperator {
        feeAddress = _feeAddress;
        emit SetFeeAddress(msg.sender, _feeAddress);
    }
    function setOperator(address _operator) external onlyOperator {
        operator = _operator;
    }

    function governanceRecoverUnsupported(
        IERC20 _token,
        uint256 amount,
        address to
    ) external onlyOperator {
        if (block.timestamp < poolEndTime + 90 days) {
            // do not allow to drain core token (SHADOW or lps) if less than 90 days after pool ends
            require(_token != shadow, "shadow");
            uint256 length = poolInfo.length;
            for (uint256 pid = 0; pid < length; ++pid) {
                PoolInfo storage pool = poolInfo[pid];
                require(_token != pool.token, "pool.token");
            }
        }
        _token.safeTransfer(to, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_shadow","type":"address"},{"internalType":"address","name":"_devFund","type":"address"},{"internalType":"address","name":"_feeAddress","type":"address"},{"internalType":"uint256","name":"_poolStartTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"TOTAL_REWARDS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"},{"internalType":"uint256","name":"_lastRewardTime","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devFund","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fromTime","type":"uint256"},{"internalType":"uint256","name":"_toTime","type":"uint256"}],"name":"getGeneratedReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"governanceRecoverUnsupported","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingSHADOW","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"accShadowPerShare","type":"uint256"},{"internalType":"bool","name":"isStarted","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"runningTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"setOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shadow","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"shadowPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000828f1779b1b28fa6e9784d38db722153bb754320000000000000000000000000a99fa2707ec6fe5ab4b14c88431c40f1ff3b9a98000000000000000000000000a99fa2707ec6fe5ab4b14c88431c40f1ff3b9a980000000000000000000000000000000000000000000000000000000067bf2892

-----Decoded View---------------
Arg [0] : _shadow (address): 0x828F1779B1B28Fa6e9784D38dB722153BB754320
Arg [1] : _devFund (address): 0xa99fa2707Ec6FE5Ab4b14C88431c40F1FF3B9A98
Arg [2] : _feeAddress (address): 0xa99fa2707Ec6FE5Ab4b14C88431c40F1FF3B9A98
Arg [3] : _poolStartTime (uint256): 1740581010

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000828f1779b1b28fa6e9784d38db722153bb754320
Arg [1] : 000000000000000000000000a99fa2707ec6fe5ab4b14c88431c40f1ff3b9a98
Arg [2] : 000000000000000000000000a99fa2707ec6fe5ab4b14c88431c40f1ff3b9a98
Arg [3] : 0000000000000000000000000000000000000000000000000000000067bf2892

33670:12186:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35504:51;;35544:11;35504:51;;;;;9985:25:1;;;9973:2;9958:18;35504:51:0;;;;;;;;34651:26;;;;;;:::i;:::-;;:::i;:::-;;;;4907:42:1;4895:55;;;4877:74;;4982:2;4967:18;;4960:34;;;;5010:18;;;5003:34;;;;5085:6;5073:19;5068:2;5053:18;;5046:47;5124:3;5109:19;;5102:35;5181:14;5174:22;5168:3;5153:19;;5146:51;4864:3;4849:19;34651:26:0;4831:372:1;34896:34:0;;;;;;38931:661;;;;;;:::i;:::-;;:::i;38369:485::-;;;;;;:::i;:::-;;:::i;:::-;;33846:25;;;;;;;;;;;;3581:42:1;3569:55;;;3551:74;;3539:2;3524:18;33846:25:0;3506:125:1;34593:22:0;;;;;;;;;43150:829;;;;;;:::i;:::-;;:::i;36946:1325::-;;;;;;:::i;:::-;;:::i;40783:916::-;;;;;;:::i;:::-;;:::i;44050:377::-;;;;;;:::i;:::-;;:::i;45209:644::-;;;;;;:::i;:::-;;:::i;33816:23::-;;;;;;;;;34983:28;;;;;;40527:180;;;:::i;35062:26::-;;;;;;44931:163;;;;;;:::i;:::-;;:::i;35357:50::-;;;;;;34735:64;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10195:25:1;;;10251:2;10236:18;;10229:34;;;;10168:18;34735:64:0;10150:119:1;35452:35:0;;;;;;39657:787;;;;;;:::i;:::-;;:::i;34566:20::-;;;;;;;;;45100:101;;;;;;:::i;:::-;;:::i;41734:1380::-;;;;;;:::i;:::-;;:::i;34651:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34651:26:0;;;;;;;;;;;;:::o;38931:661::-;39016:7;39053;39040:9;:20;39036:34;;-1:-1:-1;39069:1:0;39062:8;;39036:34;39096:11;;39085:7;:22;39081:504;;39141:11;;39128:9;:24;39124:38;;-1:-1:-1;39161:1:0;39154:8;;39124:38;39194:13;;39181:9;:26;39177:90;;39216:51;39251:15;;39216:30;39232:13;;39216:11;;:15;;:30;;;;:::i;:::-;:34;;:51::i;:::-;39209:58;;;;39177:90;39289:47;39320:15;;39289:26;39305:9;39289:11;;:15;;:26;;;;:::i;39081:504::-;39384:13;;39373:7;:24;39369:38;;-1:-1:-1;39406:1:0;39399:8;;39369:38;39439:13;;39426:9;:26;39422:86;;39461:47;39492:15;;39461:26;39473:13;;39461:7;:11;;:26;;;;:::i;39422:86::-;39557:15;;39530:43;;:22;:7;39542:9;39530:11;:22::i;39081:504::-;38931:661;;;;:::o;38369:485::-;36505:8;;:22;:8;36517:10;36505:22;36497:80;;;;;;;6263:2:1;36497:80:0;;;6245:21:1;6302:2;6282:18;;;6275:30;6341:34;6321:18;;;6314:62;6412:15;6392:18;;;6385:43;6445:19;;36497:80:0;;;;;;;;;38500:3:::1;38483:13;:20;;;;38475:70;;;::::0;::::1;::::0;;8159:2:1;38475:70:0::1;::::0;::::1;8141:21:1::0;8198:2;8178:18;;;8171:30;8237:34;8217:18;;;8210:62;8308:7;8288:18;;;8281:35;8333:19;;38475:70:0::1;8131:227:1::0;38475:70:0::1;38556:17;:15;:17::i;:::-;38584:21;38608:8;38617:4;38608:14;;;;;;;;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;38637;::::0;::::1;::::0;38608;;-1:-1:-1;38637:14:0::1;;38633:118;;;38686:53;38727:11;38686:36;38706:4;:15;;;38686;;:19;;:36;;;;:::i;:::-;:40:::0;::::1;:53::i;:::-;38668:15;:71:::0;38633:118:::1;38779:11;38761:4;:15;;:29;;;;38831:13;38801:8;38810:4;38801:14;;;;;;;;;;;;;;;;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;36588:1;38369:485:::0;;;:::o;43150:829::-;32497:21;:19;:21::i;:::-;43230:15:::1;43248:10;43230:28;;43269:21;43293:8;43302:4;43293:14;;;;;;;;;;;;;;;;;::::0;;;::::1;::::0;;;43342;;;43293::::1;43342::::0;;;;;;;:23:::1;::::0;::::1;::::0;;;;;;;;;43384:11;;43293:14;;;::::1;::::0;;::::1;::::0;-1:-1:-1;;;43384:22:0::1;43376:53;;;::::0;::::1;::::0;;8923:2:1;43376:53:0::1;::::0;::::1;8905:21:1::0;8962:2;8942:18;;;8935:30;9001:20;8981:18;;;8974:48;9039:18;;43376:53:0::1;8895:168:1::0;43376:53:0::1;43440:16;43451:4;43440:10;:16::i;:::-;43467;43486:70;43540:4;:15;;;43486:49;43530:4;43486:39;43502:4;:22;;;43486:4;:11;;;:15;;:39;;;;:::i;:::-;:43:::0;::::1;:49::i;:::-;:53:::0;::::1;:70::i;:::-;43467:89:::0;-1:-1:-1;43571:12:0;;43567:131:::1;;43600:37;43619:7;43628:8;43600:18;:37::i;:::-;43668:7;43657:29;;;43677:8;43657:29;;;;9985:25:1::0;;9973:2;9958:18;;9940:76;43657:29:0::1;;;;;;;;43567:131;43712:11:::0;;43708:138:::1;;43754:11:::0;;:24:::1;::::0;43770:7;43754:15:::1;:24::i;:::-;43740:38:::0;;43793:10;;:41:::1;::::0;:10:::1;;43817:7:::0;43826;43793:23:::1;:41::i;:::-;43890:22;::::0;::::1;::::0;43874:11;;:49:::1;::::0;43918:4:::1;::::0;43874:39:::1;::::0;:15:::1;:39::i;:49::-;43856:15;::::0;::::1;:67:::0;43939:32:::1;::::0;9985:25:1;;;43957:4:0;;43939:32:::1;::::0;::::1;::::0;::::1;::::0;9973:2:1;9958:18;43939:32:0::1;;;;;;;32529:1;;;;32541:20:::0;31935:1;33061:7;:22;32878:213;32541:20;43150:829;;:::o;36946:1325::-;36505:8;;:22;:8;36517:10;36505:22;36497:80;;;;;;;6263:2:1;36497:80:0;;;6245:21:1;6302:2;6282:18;;;6275:30;6341:34;6321:18;;;6314:62;6412:15;6392:18;;;6385:43;6445:19;;36497:80:0;6235:235:1;36497:80:0;37175:3:::1;37158:13;:20;;;;37150:70;;;::::0;::::1;::::0;;5857:2:1;37150:70:0::1;::::0;::::1;5839:21:1::0;5896:2;5876:18;;;5869:30;5935:34;5915:18;;;5908:62;6006:7;5986:18;;;5979:35;6031:19;;37150:70:0::1;5829:227:1::0;37150:70:0::1;37233:26;37252:6;37233:18;:26::i;:::-;37274:11;37270:61;;;37302:17;:15;:17::i;:::-;37363:13;;37345:15;:31;37341:534;;;37430:20:::0;37426:243:::1;;37489:13;;37471:31;;37426:243;;;37565:13;;37547:15;:31;37543:111;;;37621:13;;37603:31;;37543:111;37341:534;;;37737:20:::0;;;:57:::1;;;37779:15;37761;:33;37737:57;37733:131;;;37833:15;37815:33;;37733:131;37885:15;37923:13;;37904:15;:32;;37903:74;;;;37961:15;37942;:34;;37903:74;38002:157;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;::::1;::::0;;::::1;::::0;;;;;;-1:-1:-1;38002:157:0;;;;;;;::::1;::::0;::::1;::::0;;;;;;37988:8:::1;:172:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;::::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;;38002:157;;-1:-1:-1;38171:93:0::1;;38220:15;::::0;:32:::1;::::0;38240:11;38220:19:::1;:32::i;:::-;38202:15;:50:::0;38171:93:::1;36588:1;36946:1325:::0;;;;;:::o;40783:916::-;40835:21;40859:8;40868:4;40859:14;;;;;;;;;;;;;;;;;;;;;;;;;;40835:38;;40907:4;:19;;;40888:15;:38;40884:77;;40943:7;;;40884:77;40993:10;;:35;;;;;41022:4;40993:35;;;3551:74:1;40971:19:0;;40993:10;;;:20;;3524:18:1;;40993:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40971:57;-1:-1:-1;41043:16:0;41039:107;;-1:-1:-1;41098:15:0;41076:19;;;;:37;41128:7;;41039:107;41161:14;;;;;;41156:138;;41192:14;;;:21;;;;41209:4;41192:21;;;;;;41266:15;;;41246;;:36;;:19;:36::i;:::-;41228:15;:54;41156:138;41308:15;;:19;41304:340;;41344:24;41371:56;41390:4;:19;;;41411:15;41371:18;:56::i;:::-;41344:83;;41442:21;41466:58;41508:15;;41466:37;41487:4;:15;;;41466:16;:20;;:37;;;;:::i;:58::-;41442:82;-1:-1:-1;41564:68:0;41591:40;41619:11;41591:23;41442:82;41609:4;41591:17;:23::i;:40::-;41564:22;;;;;:26;:68::i;:::-;41539:22;;;:93;-1:-1:-1;;41304:340:0;-1:-1:-1;41676:15:0;41654:19;;;;:37;40783:916;;:::o;44050:377::-;44109:21;44133:8;44142:4;44133:14;;;;;;;;;;;;;;;;;;;;;;;;44182;;;44133;44182;;;;;;;44197:10;44182:26;;;;;;;44237:11;;44259:15;;;-1:-1:-1;44285:15:0;;:19;;;;44133:14;;;44315:10;;44133:14;;-1:-1:-1;44182:26:0;;44237:11;44315:44;;44182:26;44315:10;;;;44237:11;44315:23;:44::i;:::-;44375;;9985:25:1;;;44405:4:0;;44393:10;;44375:44;;9973:2:1;9958:18;44375:44:0;;;;;;;44050:377;;;;:::o;45209:644::-;36505:8;;:22;:8;36517:10;36505:22;36497:80;;;;;;;6263:2:1;36497:80:0;;;6245:21:1;6302:2;6282:18;;;6275:30;6341:34;6321:18;;;6314:62;6412:15;6392:18;;;6385:43;6445:19;;36497:80:0;6235:235:1;36497:80:0;45379:11:::1;::::0;:21:::1;::::0;45393:7:::1;45379:21;:::i;:::-;45361:15;:39;45357:447;;;45537:6;::::0;::::1;45527:16:::0;;::::1;45537:6:::0;::::1;45527:16;;45519:35;;;::::0;::::1;::::0;;7084:2:1;45519:35:0::1;::::0;::::1;7066:21:1::0;7123:1;7103:18;;;7096:29;7161:8;7141:18;;;7134:36;7187:18;;45519:35:0::1;7056:155:1::0;45519:35:0::1;45586:8;:15:::0;45569:14:::1;45616:177;45644:6;45638:3;:12;45616:177;;;45678:21;45702:8;45711:3;45702:13;;;;;;;;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;45752:10:::0;;45702:13;;-1:-1:-1;45752:10:0::1;45742:20:::0;;::::1;45752:10:::0;::::1;45742:20;;45734:43;;;::::0;::::1;::::0;;7820:2:1;45734:43:0::1;::::0;::::1;7802:21:1::0;7859:2;7839:18;;;7832:30;7898:12;7878:18;;;7871:40;7928:18;;45734:43:0::1;7792:160:1::0;45734:43:0::1;-1:-1:-1::0;45652:5:0::1;::::0;::::1;:::i;:::-;;;45616:177;;;;45357:447;;45814:31;:19;::::0;::::1;45834:2:::0;45838:6;45814:19:::1;:31::i;:::-;45209:644:::0;;;:::o;40527:180::-;40589:8;:15;40572:14;40615:85;40643:6;40637:3;:12;40615:85;;;40673:15;40684:3;40673:10;:15::i;:::-;40651:5;;;:::i;:::-;;;40615:85;;44931:163;36505:8;;:22;:8;36517:10;36505:22;36497:80;;;;;;;6263:2:1;36497:80:0;;;6245:21:1;6302:2;6282:18;;;6275:30;6341:34;6321:18;;;6314:62;6412:15;6392:18;;;6385:43;6445:19;;36497:80:0;6235:235:1;36497:80:0;45008:10:::1;:24:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;45048:38:::1;::::0;45062:10:::1;::::0;45048:38:::1;::::0;-1:-1:-1;;45048:38:0::1;44931:163:::0;:::o;39657:787::-;39732:7;39752:21;39776:8;39785:4;39776:14;;;;;;;;;;;;;;;;;;;;;;;;39825;;;39776;39825;;;;;;;:21;;;;;;;;;;;39776:14;;;;;;;39885:22;;;;;39940:10;;:35;;;;;39969:4;39940:35;;;3551:74:1;;;;39776:14:0;;-1:-1:-1;39825:21:0;;39885:22;;39776:14;;39940:10;;;;;:20;;3524:18:1;;39940:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;39918:57;;40008:4;:19;;;39990:15;:37;:57;;;;-1:-1:-1;40031:16:0;;;39990:57;39986:368;;;40064:24;40091:56;40110:4;:19;;;40131:15;40091:18;:56::i;:::-;40064:83;;40162:21;40186:58;40228:15;;40186:37;40207:4;:15;;;40186:16;:20;;:37;;;;:::i;:58::-;40162:82;-1:-1:-1;40279:63:0;40301:40;40329:11;40301:23;40162:82;40319:4;40301:17;:23::i;:40::-;40279:17;;:21;:63::i;:::-;40259:83;;39986:368;;;40371:65;40420:4;:15;;;40371:44;40410:4;40371:34;40387:17;40371:4;:11;;;:15;;:34;;;;:::i;:65::-;40364:72;39657:787;-1:-1:-1;;;;;;;39657:787:0:o;45100:101::-;36505:8;;:22;:8;36517:10;36505:22;36497:80;;;;;;;6263:2:1;36497:80:0;;;6245:21:1;6302:2;6282:18;;;6275:30;6341:34;6321:18;;;6314:62;6412:15;6392:18;;;6385:43;6445:19;;36497:80:0;6235:235:1;36497:80:0;45173:8:::1;:20:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;45100:101::o;41734:1380::-;32497:21;:19;:21::i;:::-;41813:15:::1;41831:10;41813:28;;41852:21;41876:8;41885:4;41876:14;;;;;;;;;;;;;;;;;::::0;;;::::1;::::0;;;41925;;;41876::::1;41925::::0;;;;;;;:23:::1;::::0;::::1;::::0;;;;;;;;;41876:14;::::1;::::0;;::::1;::::0;-1:-1:-1;41959:16:0::1;41934:4:::0;41959:10:::1;:16::i;:::-;41990:11:::0;;:15;41986:294:::1;;42022:16;42041:70;42095:4;:15;;;42041:49;42085:4;42041:39;42057:4;:22;;;42041:4;:11;;;:15;;:39;;;;:::i;:70::-;42022:89:::0;-1:-1:-1;42130:12:0;;42126:143:::1;;42163:37;42182:7;42191:8;42163:18;:37::i;:::-;42235:7;42224:29;;;42244:8;42224:29;;;;9985:25:1::0;;9973:2;9958:18;;9940:76;42224:29:0::1;;;;;;;;42126:143;41986:294;;42294:11:::0;;42290:692:::1;;42322:10:::0;;:60:::1;::::0;:10:::1;;42350:7:::0;42367:4:::1;42374:7:::0;42322:27:::1;:60::i;:::-;42424:7;::::0;42409:10;;42424:7:::1;42409:10:::0;;::::1;42424:7:::0;::::1;42401:30;42397:129;;;42466:45;42482:28;42504:5;42482:17;:7:::0;42494:4:::1;42482:11;:17::i;:28::-;42466:11:::0;;;:15:::1;:45::i;:::-;42452:59:::0;;42397:129:::1;42545:17;::::0;::::1;::::0;::::1;;:21:::0;42541:430:::1;;42620:17;::::0;::::1;::::0;42587:18:::1;::::0;42608:41:::1;::::0;42643:5:::1;::::0;42608:30:::1;::::0;:7;;42620:17:::1;;42608:11;:30::i;:41::-;42692:10;::::0;42668;;42587:62;;-1:-1:-1;42668:47:0::1;::::0;42692:10:::1;42668::::0;;::::1;::::0;42692::::1;42587:62:::0;42668:23:::1;:47::i;:::-;42821:11:::0;;:40:::1;::::0;42850:10;;42821:24:::1;::::0;42837:7;42821:15:::1;:24::i;:40::-;42807:54:::0;;-1:-1:-1;42541:430:0::1;;;42931:11:::0;;:24:::1;::::0;42947:7;42931:15:::1;:24::i;:::-;42917:38:::0;;42541:430:::1;43026:22;::::0;::::1;::::0;43010:11;;:49:::1;::::0;43054:4:::1;::::0;43010:39:::1;::::0;:15:::1;:39::i;:49::-;42992:15;::::0;::::1;:67:::0;43075:31:::1;::::0;9985:25:1;;;43092:4:0;;43075:31:::1;::::0;::::1;::::0;::::1;::::0;9973:2:1;9958:18;43075:31:0::1;;;;;;;32529:1;;;32541:20:::0;31935:1;33061:7;:22;32878:213;6018:98;6076:7;6103:5;6107:1;6103;:5;:::i;:::-;6096:12;6018:98;-1:-1:-1;;;6018:98:0:o;6375:::-;6433:7;6460:5;6464:1;6460;:5;:::i;5637:98::-;5695:7;5722:5;5726:1;5722;:5;:::i;32577:293::-;31979:1;32711:7;;:19;;32703:63;;;;;;;9681:2:1;32703:63:0;;;9663:21:1;9720:2;9700:18;;;9693:30;9759:33;9739:18;;;9732:61;9810:18;;32703:63:0;9653:181:1;32703:63:0;31979:1;32844:7;:18;32577:293::o;6774:98::-;6832:7;6859:5;6863:1;6859;:5;:::i;44544:381::-;44647:6;;:31;;;;;44672:4;44647:31;;;3551:74:1;44622:22:0;;44647:6;;;:16;;3524:18:1;;44647:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;44622:56;-1:-1:-1;44693:18:0;;44689:229;;44742:14;44732:7;:24;44728:179;;;44777:6;;:40;;:6;;44797:3;44802:14;44777:19;:40::i;:::-;44728:179;;;44858:6;;:33;;:6;;44878:3;44883:7;24102:177;24212:58;;4243:42:1;4231:55;;24212:58:0;;;4213:74:1;4303:18;;;4296:34;;;24185:86:0;;24205:5;;24235:23;;4186:18:1;;24212:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24185:19;:86::i;36605:263::-;36690:8;:15;36673:14;36716:145;36744:6;36738:3;:12;36716:145;;;36805:6;36782:29;;:8;36791:3;36782:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:19;;;:29;;36774:75;;;;;;;7418:2:1;36774:75:0;;;7400:21:1;7457:2;7437:18;;;7430:30;7496:34;7476:18;;;7469:62;7567:3;7547:18;;;7540:31;7588:19;;36774:75:0;7390:223:1;36774:75:0;36752:5;;;:::i;:::-;;;36716:145;;24524:205;24652:68;;3848:42:1;3917:15;;;24652:68:0;;;3899:34:1;3969:15;;3949:18;;;3942:43;4001:18;;;3994:34;;;24625:96:0;;24645:5;;24675:27;;3811:18:1;;24652:68:0;3793:241:1;24625:96:0;24524:205;;;;:::o;28448:649::-;28872:23;28898:69;28926:4;28898:69;;;;;;;;;;;;;;;;;28906:5;28898:27;;;;:69;;;;;:::i;:::-;28872:95;;28986:10;:17;29007:1;28986:22;:56;;;;29023:10;29012:30;;;;;;;;;;;;:::i;:::-;28978:111;;;;;;;9270:2:1;28978:111:0;;;9252:21:1;9309:2;9289:18;;;9282:30;9348:34;9328:18;;;9321:62;9419:12;9399:18;;;9392:40;9449:19;;28978:111:0;9242:232:1;13935:229:0;14072:12;14104:52;14126:6;14134:4;14140:1;14143:12;14104:21;:52::i;:::-;14097:59;13935:229;-1:-1:-1;;;;13935:229:0:o;15021:455::-;15191:12;15249:5;15224:21;:30;;15216:81;;;;;;;6677:2:1;15216:81:0;;;6659:21:1;6716:2;6696:18;;;6689:30;6755:34;6735:18;;;6728:62;6826:8;6806:18;;;6799:36;6852:19;;15216:81:0;6649:228:1;15216:81:0;15309:12;15323:23;15350:6;:11;;15369:5;15376:4;15350:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15308:73;;;;15399:69;15426:6;15434:7;15443:10;15455:12;17779;17808:7;17804:427;;;17836:17;;17832:290;;18054:18;18065:6;18054:10;:18::i;:::-;18046:60;;;;;;;8565:2:1;18046:60:0;;;8547:21:1;8604:2;8584:18;;;8577:30;8643:31;8623:18;;;8616:59;8692:18;;18046:60:0;8537:179:1;18046:60:0;-1:-1:-1;18143:10:0;18136:17;;17804:427;18186:33;18194:10;18206:12;18186:7;:33::i;11180:326::-;11475:19;;;;:23;;11180:326;;;;:::o;18780:552::-;18941:17;;:21;18937:388;;19173:10;19167:17;19230:15;19217:10;19213:2;19209:19;19202:44;19125:136;19300:12;19293:20;;;;;;;;;;;:::i;14:159:1:-;81:20;;141:6;130:18;;120:29;;110:2;;163:1;160;153:12;178:257;;290:2;278:9;269:7;265:23;261:32;258:2;;;311:6;303;296:22;258:2;355:9;342:23;374:31;399:5;374:31;:::i;440:255::-;;560:2;548:9;539:7;535:23;531:32;528:2;;;581:6;573;566:22;528:2;618:9;612:16;637:28;659:5;637:28;:::i;700:479::-;;;;859:2;847:9;838:7;834:23;830:32;827:2;;;880:6;872;865:22;827:2;924:9;911:23;943:31;968:5;943:31;:::i;:::-;993:5;-1:-1:-1;1045:2:1;1030:18;;1017:32;;-1:-1:-1;1101:2:1;1086:18;;1073:32;1114:33;1073:32;1114:33;:::i;:::-;1166:7;1156:17;;;817:362;;;;;:::o;1184:190::-;;1296:2;1284:9;1275:7;1271:23;1267:32;1264:2;;;1317:6;1309;1302:22;1264:2;-1:-1:-1;1345:23:1;;1254:120;-1:-1:-1;1254:120:1:o;1379:194::-;;1502:2;1490:9;1481:7;1477:23;1473:32;1470:2;;;1523:6;1515;1508:22;1470:2;-1:-1:-1;1551:16:1;;1460:113;-1:-1:-1;1460:113:1:o;1578:325::-;;;1707:2;1695:9;1686:7;1682:23;1678:32;1675:2;;;1728:6;1720;1713:22;1675:2;1769:9;1756:23;1746:33;;1829:2;1818:9;1814:18;1801:32;1842:31;1867:5;1842:31;:::i;:::-;1892:5;1882:15;;;1665:238;;;;;:::o;1908:615::-;;;;;;2097:3;2085:9;2076:7;2072:23;2068:33;2065:2;;;2119:6;2111;2104:22;2065:2;2160:9;2147:23;2137:33;;2220:2;2209:9;2205:18;2192:32;2233:31;2258:5;2233:31;:::i;:::-;2283:5;-1:-1:-1;2340:2:1;2325:18;;2312:32;2353:30;2312:32;2353:30;:::i;:::-;2402:7;-1:-1:-1;2456:2:1;2441:18;;2428:32;;-1:-1:-1;2479:38:1;2512:3;2497:19;;2479:38;:::i;:::-;2469:48;;2055:468;;;;;;;;:::o;2528:258::-;;;2657:2;2645:9;2636:7;2632:23;2628:32;2625:2;;;2678:6;2670;2663:22;2625:2;-1:-1:-1;;2706:23:1;;;2776:2;2761:18;;;2748:32;;-1:-1:-1;2615:171:1:o;2791:330::-;;;;2936:2;2924:9;2915:7;2911:23;2907:32;2904:2;;;2957:6;2949;2942:22;2904:2;2998:9;2985:23;2975:33;;3055:2;3044:9;3040:18;3027:32;3017:42;;3078:37;3111:2;3100:9;3096:18;3078:37;:::i;:::-;3068:47;;2894:227;;;;;:::o;3126:274::-;;3293:6;3287:13;3309:53;3355:6;3350:3;3343:4;3335:6;3331:17;3309:53;:::i;:::-;3378:16;;;;;3263:137;-1:-1:-1;;3263:137:1:o;5208:442::-;;5357:2;5346:9;5339:21;5389:6;5383:13;5432:6;5427:2;5416:9;5412:18;5405:34;5448:66;5507:6;5502:2;5491:9;5487:18;5482:2;5474:6;5470:15;5448:66;:::i;:::-;5566:2;5554:15;5571:66;5550:88;5535:104;;;;5641:2;5531:113;;5329:321;-1:-1:-1;;5329:321:1:o;10274:128::-;;10345:1;10341:6;10338:1;10335:13;10332:2;;;10351:18;;:::i;:::-;-1:-1:-1;10387:9:1;;10322:80::o;10407:274::-;;10473:1;10463:2;;10508:77;10505:1;10498:88;10609:4;10606:1;10599:15;10637:4;10634:1;10627:15;10463:2;-1:-1:-1;10666:9:1;;10453:228::o;10686:::-;;10852:1;10784:66;10780:74;10777:1;10774:81;10769:1;10762:9;10755:17;10751:105;10748:2;;;10859:18;;:::i;:::-;-1:-1:-1;10899:9:1;;10738:176::o;10919:125::-;;10987:1;10984;10981:8;10978:2;;;10992:18;;:::i;:::-;-1:-1:-1;11029:9:1;;10968:76::o;11049:258::-;11121:1;11131:113;11145:6;11142:1;11139:13;11131:113;;;11221:11;;;11215:18;11202:11;;;11195:39;11167:2;11160:10;11131:113;;;11262:6;11259:1;11256:13;11253:2;;;-1:-1:-1;;11297:1:1;11279:16;;11272:27;11102:205::o;11312:195::-;;11382:66;11375:5;11372:77;11369:2;;;11452:18;;:::i;:::-;-1:-1:-1;11499:1:1;11488:13;;11359:148::o;11512:184::-;11564:77;11561:1;11554:88;11661:4;11658:1;11651:15;11685:4;11682:1;11675:15;11701:154;11787:42;11780:5;11776:54;11769:5;11766:65;11756:2;;11845:1;11842;11835:12;11860:118;11946:5;11939:13;11932:21;11925:5;11922:32;11912:2;;11968:1;11965;11958:12

ipfs://2ed670e6ad850e293d4ce72b74a5794302cec64ae788eefbdf2bbdcb6e2220be