Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Address
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(bool succes ...
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• 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 SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
•    - function _msgSender()
•    - function _msgData()
•    - function _contextSuffixLength()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library Math
•    - 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 max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
•    - function unsignedRoundsUp(Rounding ro ...
• interface IUniswapV2Router02
•    - function factory()
•    - function WETH()
•    - function addLiquidity(
•    - function addLiquidityETH(
•  contract TabsXStakingContract is O ... *
•    - function lastTimeRewardApplicable()
•    - function rewardPerToken()
•    - function earned(address account)
•    - function stake(uint256 amount)
•    - function unstake(uint256 amount)
•    - function claimUnstakedAmount()
•    - function totalUnstakedAmountReadyToCl ...
•    - function totalUnstakedTokenAmount(add ...
•    - function getUnboundingTime(address us ...
•    - function exit()
•    - function getReward()
•    - function initRewardAmount(uint256 rew ...
•    - function setRewardDistributor(address ...
•    - function setDurationAndFee(uint256 _d ...
•    - function setUnboundingDuration(uint25 ...
•    - function stopRewardDistribution()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function recoverExcessToken(address t ...
•    - function _addLiquidity(uint256 amount ...
•    - function sendETHValue(address payable ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-01-26
*/

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) 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 FailedInnerCall();
        }
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @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/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




/**
 * @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 An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @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.encodeCall(token.transfer, (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.encodeCall(token.transferFrom, (from, to, 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);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @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.encodeCall(token.approve, (spender, value));

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

    /**
     * @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);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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(token).code.length > 0;
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    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.
     */
    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.
     */
    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.
     */
    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.
     */
    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 largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

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

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

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

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

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// File: contracts/TabsxStake.sol

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





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

    function WETH() external pure returns (address);

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

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

}
contract TabsXStakingContract is Ownable {
 
    using SafeERC20 for IERC20;
    IERC20 public stakeToken;
    IERC20 public rewardToken;

    uint256 public duration = 0;
    uint256 public unboundingDuration = 0;
    uint256 private _totalSupply;
    uint256 public periodFinish = 0;
    uint256 public rewardRate = 0;
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;
    uint256 private withdrawalFee = 0.05 ether;
    address public tasbxAdmin;

    IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(
    0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D 
    );

    struct Unstake {
        uint256 unstakingAmount;
        uint256 unstakingTime;
    }
    struct UserData {
        uint256 rewards;
        uint256 userRewardPerTokenPaid;
    
    }

    mapping(address => UserData) public userRewardInfo;

    mapping(address => uint256) private _balances;

    mapping(address => Unstake) private _userUnstake;

    event RewardAdded(uint256 reward);
    event Staked(address indexed user, uint256 amount);
    event Unstaked(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);
    event RecoverToken(address indexed token, uint256 indexed amount);
    event UnstakeAmountClaimed(address indexed user, uint256 amount);
    event RewardDistributionStarted(uint256 periodFinish);

    modifier onlyRewardDistributor() {
        require(
            msg.sender == tasbxAdmin,
            "Caller is not reward Distributor"
        );
        _;
    }

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

    constructor(
        IERC20 _stakeToken,
        IERC20 _rewardToken,
        uint256 _duration,
        uint256 _unboundingDuration
    )  Ownable(msg.sender)  {

        stakeToken = _stakeToken;
        rewardToken = _rewardToken;
        duration = _duration;
        unboundingDuration = _unboundingDuration;
  
    }

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

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

     
        return
            rewardPerTokenStored+lTRwApp;
    }

    function earned(address account) public view returns (uint256 earn) {

        earn = rewardPerToken()-userRewardInfo[account].userRewardPerTokenPaid;
        earn = (earn * balanceOf(account))/1e18;
        earn +=userRewardInfo[account].rewards;

        // return
        //     balanceOf(account)
        //         .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
        //         .div(1e18)
        //         .add(rewards[account]);
    }


    function stake(uint256 amount) payable public updateReward(msg.sender) {
        require(amount > 0 && msg.value >0, "Cannot stake 0");

        rewardToken.safeTransferFrom(msg.sender, address(this), amount);
        (uint256 aT,uint256 aE, uint256 li) = _addLiquidity(amount);
        _totalSupply += li;
        _balances[msg.sender] += (li);
        //send back the dust to the user
        sendETHValue(payable(msg.sender), msg.value-aE);
        emit Staked(msg.sender, li);
    }

    function unstake(uint256 amount) payable public updateReward(msg.sender) {
        require(amount > 0 && msg.value >= withdrawalFee, "Cannot withdraw 0 | pay withdrawal Fee");
         sendETHValue(payable(tasbxAdmin), msg.value);
        require(
            _balances[msg.sender] >= amount,
            "User does not have sufficient balance"
        );
        _totalSupply = _totalSupply-(amount);
        _balances[msg.sender] = _balances[msg.sender]-(amount);
        getReward();
        if (unboundingDuration == 0) {
            stakeToken.safeTransfer(msg.sender, amount);
        } else {
            uint256 unboundingPeriodFinish = block.timestamp+(unboundingDuration);
            Unstake storage accountUnstake = _userUnstake[msg.sender];
            accountUnstake.unstakingAmount = (accountUnstake.unstakingAmount)+(amount);
            accountUnstake.unstakingTime = unboundingPeriodFinish;
        }

        emit Unstaked(msg.sender, amount);
    }



    function claimUnstakedAmount() external {
        Unstake storage accountUnstake = _userUnstake[msg.sender];

        require(
            accountUnstake.unstakingAmount > 0,
            "No unstaked amount to claim"
        );
        require(
            block.timestamp >= accountUnstake.unstakingTime,
            "Unbounding period not finished"
        );

        uint256 totalUnstakedAmount = accountUnstake.unstakingAmount;

        accountUnstake.unstakingAmount = 0;
        accountUnstake.unstakingTime = 0;

        stakeToken.safeTransfer(msg.sender, totalUnstakedAmount);
        emit UnstakeAmountClaimed(msg.sender, totalUnstakedAmount);
    }

    function totalUnstakedAmountReadyToClaim(address user)
        external
        view
        returns (uint256)
    {
        if (block.timestamp >= _userUnstake[user].unstakingTime) {
            return _userUnstake[user].unstakingAmount;
        }
        return 0;
    }

    function totalUnstakedTokenAmount(address user) external view returns (uint256) {
        return _userUnstake[user].unstakingAmount;
    }
    
    function getUnboundingTime(address user) external view returns (uint256) {
        return _userUnstake[user].unstakingTime;
    }

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

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

    function initRewardAmount(uint256 reward)
        external
        onlyRewardDistributor
        updateReward(address(0))
    {
        if (block.timestamp >= periodFinish) {
            rewardRate = reward/(duration);
        } else {
            uint256 remaining = periodFinish - (block.timestamp);
            uint256 leftover = remaining *(rewardRate);
            rewardRate = (reward + (leftover))/(duration);
        }
        lastUpdateTime = block.timestamp;
        periodFinish = block.timestamp + (duration);

        //Infinite allowance during initialising
        rewardToken.approve(address(uniswapV2Router),type(uint256).max);
        emit RewardDistributionStarted(periodFinish);
    }

    function setRewardDistributor(address _rewardDistributor)
        external
        onlyOwner
    {
        tasbxAdmin = _rewardDistributor;
    }

    function setDurationAndFee(uint256 _duration,uint256 _fee) external onlyRewardDistributor {
        duration = _duration;
        periodFinish = block.timestamp + (duration);
        withdrawalFee = _fee;
    }

    function setUnboundingDuration(uint256 _unboundingDuration)
        external
        onlyRewardDistributor
    {
        unboundingDuration = _unboundingDuration;
    }

    function stopRewardDistribution() external onlyRewardDistributor {
        periodFinish = block.timestamp;
    }



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

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

    function recoverExcessToken(address token, uint256 amount)
        external
        onlyRewardDistributor
    {
        IERC20(token).safeTransfer(msg.sender, amount);
        emit RecoverToken(token, amount);
    }
    function _addLiquidity(uint256 amount) internal  returns(uint256,uint256,uint256) {
        // approve token transfer to cover all possible scenarios


        (uint256 amountToken, uint256 amountETH, uint256 liquidity)=uniswapV2Router.addLiquidityETH{value: msg.value}(
            address(rewardToken), //token address
            amount, // liquidity amount
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            address(this), // LP tokens are sent to the owner
            block.timestamp
        );

        return (amountToken,amountETH,liquidity);
       
    }
    function sendETHValue(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");
    }
    receive() payable external{
   
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_stakeToken","type":"address"},{"internalType":"contract IERC20","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_duration","type":"uint256"},{"internalType":"uint256","name":"_unboundingDuration","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"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":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RecoverToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"periodFinish","type":"uint256"}],"name":"RewardDistributionStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"UnstakeAmountClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unstaked","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimUnstakedAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"earn","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getUnboundingTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"name":"initRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverExcessToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_duration","type":"uint256"},{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setDurationAndFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardDistributor","type":"address"}],"name":"setRewardDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_unboundingDuration","type":"uint256"}],"name":"setUnboundingDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"stakeToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stopRewardDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tasbxAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"totalUnstakedAmountReadyToClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"totalUnstakedTokenAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unboundingDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"unstake","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardInfo","outputs":[{"internalType":"uint256","name":"rewards","type":"uint256"},{"internalType":"uint256","name":"userRewardPerTokenPaid","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000020a9d6939dde9e7efc320467d53abfcd61d946740000000000000000000000009427c5a704dfbfecdf4227d11048d64cb6882d8000000000000000000000000000000000000000000000000000000000004f1a000000000000000000000000000000000000000000000000000000000000015180

-----Decoded View---------------
Arg [0] : _stakeToken (address): 0x20A9D6939DDe9e7EFC320467d53aBfcD61d94674
Arg [1] : _rewardToken (address): 0x9427C5a704DFbFECdf4227D11048d64cb6882D80
Arg [2] : _duration (uint256): 5184000
Arg [3] : _unboundingDuration (uint256): 86400

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000020a9d6939dde9e7efc320467d53abfcd61d94674
Arg [1] : 0000000000000000000000009427c5a704dfbfecdf4227d11048d64cb6882d80
Arg [2] : 00000000000000000000000000000000000000000000000000000000004f1a00
Arg [3] : 0000000000000000000000000000000000000000000000000000000000015180

39717:9359:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42522:469;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39866:27;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47633:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40180:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45633:131;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43505:988;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40535:50;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;45884:324;;;;;;;;;;;;;:::i;:::-;;44505:679;;;;;;;;;;;;;:::i;:::-;;39801:24;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46216:722;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47732:110;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22412:103;;;;;;;;;;;;;:::i;:::-;;40017:29;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42021:131;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21737:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46946:150;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43001:496;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47850:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47507:114;;;;;;;;;;;;;:::i;:::-;;40053:29;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42160:354;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45481:140;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40089:35;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47104:214;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45192:281;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45772:104;;;:::i;:::-;;39979:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22670:220;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47326:173;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39832:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39900:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42522:469;42576:12;42627:14;:23;42642:7;42627:23;;;;;;;;;;;;;;;:46;;;42610:16;:14;:16::i;:::-;:63;;;;:::i;:::-;42603:70;;42719:4;42699:18;42709:7;42699:9;:18::i;:::-;42692:4;:25;;;;:::i;:::-;42691:32;;;;:::i;:::-;42684:39;;42741:14;:23;42756:7;42741:23;;;;;;;;;;;;;;;:31;;;42734:38;;;;;:::i;:::-;;;42522:469;;;:::o;39866:27::-;;;;:::o;47633:91::-;47677:7;47704:12;;47697:19;;47633:91;:::o;40180:25::-;;;;;;;;;;;;;:::o;45633:131::-;45697:7;45724:12;:18;45737:4;45724:18;;;;;;;;;;;;;;;:32;;;45717:39;;45633:131;;;:::o;43505:988::-;43566:10;41378:16;:14;:16::i;:::-;41355:20;:39;;;;41422:26;:24;:26::i;:::-;41405:14;:43;;;;41482:1;41463:21;;:7;:21;;;41459:187;;41535:15;41542:7;41535:6;:15::i;:::-;41501:14;:23;41516:7;41501:23;;;;;;;;;;;;;;;:31;;:49;;;;41614:20;;41565:14;:23;41580:7;41565:23;;;;;;;;;;;;;;;:46;;:69;;;;41459:187;43606:1:::1;43597:6;:10;:40;;;;;43624:13;;43611:9;:26;;43597:40;43589:91;;;;;;;;;;;;:::i;:::-;;;;;;;;;43692:44;43713:10;;;;;;;;;;;43726:9;43692:12;:44::i;:::-;43794:6;43769:9;:21;43779:10;43769:21;;;;;;;;;;;;;;;;:31;;43747:118;;;;;;;;;;;;:::i;:::-;;;;;;;;;43905:6;43891:12;;:21;;;;:::i;:::-;43876:12;:36;;;;43970:6;43947:9;:21;43957:10;43947:21;;;;;;;;;;;;;;;;:30;;;;:::i;:::-;43923:9;:21;43933:10;43923:21;;;;;;;;;;;;;;;:54;;;;43988:11;:9;:11::i;:::-;44036:1;44014:18;;:23:::0;44010:430:::1;;44054:43;44078:10;44090:6;44054:10;;;;;;;;;;;:23;;;;:43;;;;;:::i;:::-;44010:430;;;44130:30;44180:18;;44163:15;:36;;;;:::i;:::-;44130:69;;44214:30;44247:12;:24;44260:10;44247:24;;;;;;;;;;;;;;;44214:57;;44353:6;44320:14;:30;;;44319:41;;;;:::i;:::-;44286:14;:30;;:74;;;;44406:22;44375:14;:28;;:53;;;;44115:325;;44010:430;44466:10;44457:28;;;44478:6;44457:28;;;;;;:::i;:::-;;;;;;;;43505:988:::0;;:::o;40535:50::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;45884:324::-;45925:10;41378:16;:14;:16::i;:::-;41355:20;:39;;;;41422:26;:24;:26::i;:::-;41405:14;:43;;;;41482:1;41463:21;;:7;:21;;;41459:187;;41535:15;41542:7;41535:6;:15::i;:::-;41501:14;:23;41516:7;41501:23;;;;;;;;;;;;;;;:31;;:49;;;;41614:20;;41565:14;:23;41580:7;41565:23;;;;;;;;;;;;;;;:46;;:69;;;;41459:187;45949:14:::1;45966;:26;45981:10;45966:26;;;;;;;;;;;;;;;:34;;;45949:51;;46024:1;46015:6;:10;46011:190;;;46079:1;46042:14;:26;46057:10;46042:26;;;;;;;;;;;;;;;:34;;:38;;;;46095:44;46120:10;46132:6;46095:11;;;;;;;;;;;:24;;;;:44;;;;;:::i;:::-;46170:10;46159:30;;;46182:6;46159:30;;;;;;:::i;:::-;;;;;;;;46011:190;45937:271;45884:324:::0;:::o;44505:679::-;44556:30;44589:12;:24;44602:10;44589:24;;;;;;;;;;;;;;;44556:57;;44681:1;44648:14;:30;;;:34;44626:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;44789:14;:28;;;44770:15;:47;;44748:127;;;;;;;;;;;;:::i;:::-;;;;;;;;;44888:27;44918:14;:30;;;44888:60;;44994:1;44961:14;:30;;:34;;;;45037:1;45006:14;:28;;:32;;;;45051:56;45075:10;45087:19;45051:10;;;;;;;;;;;:23;;;;:56;;;;;:::i;:::-;45144:10;45123:53;;;45156:19;45123:53;;;;;;:::i;:::-;;;;;;;;44545:639;;44505:679::o;39801:24::-;;;;;;;;;;;;;:::o;46216:722::-;41207:10;;;;;;;;;;;41193:24;;:10;:24;;;41171:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;46337:1:::1;41378:16;:14;:16::i;:::-;41355:20;:39;;;;41422:26;:24;:26::i;:::-;41405:14;:43;;;;41482:1;41463:21;;:7;:21;;;41459:187;;41535:15;41542:7;41535:6;:15::i;:::-;41501:14;:23;41516:7;41501:23;;;;;;;;;;;;;;;:31;;:49;;;;41614:20;;41565:14;:23;41580:7;41565:23;;;;;;;;;;;;;;;:46;;:69;;;;41459:187;46380:12:::2;;46361:15;:31;46357:296;;46430:8;;46422:6;:17;;;;:::i;:::-;46409:10;:30;;;;46357:296;;;46472:17;46508:15;46492:12;;:32;;;;:::i;:::-;46472:52;;46539:16;46570:10;;46558:9;:23;;;;:::i;:::-;46539:42;;46632:8;;46620;46610:6;:19;;;;:::i;:::-;46609:32;;;;:::i;:::-;46596:10;:45;;;;46457:196;;46357:296;46680:15;46663:14;:32;;;;46740:8;;46721:15;:28;;;;:::i;:::-;46706:12;:43;;;;46812:11;;;;;;;;;;;:19;;;46840:15;;;;;;;;;;;46857:17;46812:63;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46891:39;46917:12;;46891:39;;;;;;:::i;:::-;;;;;;;;41288:1:::1;46216:722:::0;:::o;47732:110::-;47789:7;47816:9;:18;47826:7;47816:18;;;;;;;;;;;;;;;;47809:25;;47732:110;;;:::o;22412:103::-;21623:13;:11;:13::i;:::-;22477:30:::1;22504:1;22477:18;:30::i;:::-;22412:103::o:0;40017:29::-;;;;:::o;42021:131::-;42078:7;42105:39;42114:15;42131:12;;42105:8;:39::i;:::-;42098:46;;42021:131;:::o;21737:87::-;21783:7;21810:6;;;;;;;;;;;21803:13;;21737:87;:::o;46946:150::-;21623:13;:11;:13::i;:::-;47070:18:::1;47057:10;;:31;;;;;;;;;;;;;;;;;;46946:150:::0;:::o;43001:496::-;43060:10;41378:16;:14;:16::i;:::-;41355:20;:39;;;;41422:26;:24;:26::i;:::-;41405:14;:43;;;;41482:1;41463:21;;:7;:21;;;41459:187;;41535:15;41542:7;41535:6;:15::i;:::-;41501:14;:23;41516:7;41501:23;;;;;;;;;;;;;;;:31;;:49;;;;41614:20;;41565:14;:23;41580:7;41565:23;;;;;;;;;;;;;;;:46;;:69;;;;41459:187;43100:1:::1;43091:6;:10;:26;;;;;43116:1;43105:9;:12;43091:26;43083:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;43149:63;43178:10;43198:4;43205:6;43149:11;;;;;;;;;;;:28;;;;:63;;;;;;:::i;:::-;43224:10;43235::::0;43247::::1;43261:21;43275:6;43261:13;:21::i;:::-;43223:59;;;;;;43309:2;43293:12;;:18;;;;;;;:::i;:::-;;;;;;;;43348:2;43322:9;:21;43332:10;43322:21;;;;;;;;;;;;;;;;:29;;;;;;;:::i;:::-;;;;;;;;43404:47;43425:10;43448:2;43438:9;:12;;;;:::i;:::-;43404;:47::i;:::-;43474:10;43467:22;;;43486:2;43467:22;;;;;;:::i;:::-;;;;;;;;43072:425;;;43001:496:::0;;:::o;47850:221::-;41207:10;;;;;;;;;;;41193:24;;:10;:24;;;41171:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;47974:46:::1;48001:10;48013:6;47981:5;47974:26;;;;:46;;;;;:::i;:::-;48056:6;48049:5;48036:27;;;;;;;;;;;;47850:221:::0;;:::o;47507:114::-;41207:10;;;;;;;;;;;41193:24;;:10;:24;;;41171:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;47598:15:::1;47583:12;:30;;;;47507:114::o:0;40053:29::-;;;;:::o;42160:354::-;42207:7;42248:1;42231:13;:11;:13::i;:::-;:18;42227:78;;42273:20;;42266:27;;;;42227:78;42315:15;42360:14;;42333:26;:24;:26::i;:::-;:41;;;;:::i;:::-;42315:59;;42425:13;:11;:13::i;:::-;42419:4;42406:10;;42396:7;:20;;;;:::i;:::-;:27;;;;:::i;:::-;42395:43;;;;:::i;:::-;42385:53;;42499:7;42478:20;;:28;;;;:::i;:::-;42458:48;;;42160:354;;:::o;45481:140::-;45552:7;45579:12;:18;45592:4;45579:18;;;;;;;;;;;;;;;:34;;;45572:41;;45481:140;;;:::o;40089:35::-;;;;:::o;47104:214::-;41207:10;;;;;;;;;;;41193:24;;:10;:24;;;41171:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;47216:9:::1;47205:8;:20;;;;47270:8;;47251:15;:28;;;;:::i;:::-;47236:12;:43;;;;47306:4;47290:13;:20;;;;47104:214:::0;;:::o;45192:281::-;45297:7;45345:12;:18;45358:4;45345:18;;;;;;;;;;;;;;;:32;;;45326:15;:51;45322:125;;45401:12;:18;45414:4;45401:18;;;;;;;;;;;;;;;:34;;;45394:41;;;;45322:125;45464:1;45457:8;;45192:281;;;;:::o;45772:104::-;45816:30;45824:21;45834:10;45824:9;:21::i;:::-;45816:7;:30::i;:::-;45857:11;:9;:11::i;:::-;45772:104::o;39979:31::-;;;;:::o;22670:220::-;21623:13;:11;:13::i;:::-;22775:1:::1;22755:22;;:8;:22;;::::0;22751:93:::1;;22829:1;22801:31;;;;;;;;;;;:::i;:::-;;;;;;;;22751:93;22854:28;22873:8;22854:18;:28::i;:::-;22670:220:::0;:::o;47326:173::-;41207:10;;;;;;;;;;;41193:24;;:10;:24;;;41171:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;47472:19:::1;47451:18;:40;;;;47326:173:::0;:::o;39832:25::-;;;;;;;;;;;;;:::o;39900:37::-;;;;:::o;48708:320::-;48826:6;48801:21;:31;;48793:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;48880:12;48898:9;:14;;48920:6;48898:33;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48879:52;;;48950:7;48942:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;48782:246;48708:320;;:::o;14499:162::-;14582:71;14602:5;14624;:14;;;14641:2;14645:5;14609:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14582:19;:71::i;:::-;14499:162;;;:::o;21902:166::-;21973:12;:10;:12::i;:::-;21962:23;;:7;:5;:7::i;:::-;:23;;;21958:103;;22036:12;:10;:12::i;:::-;22009:40;;;;;;;;;;;:::i;:::-;;;;;;;;21958:103;21902:166::o;23050:191::-;23124:16;23143:6;;;;;;;;;;;23124:25;;23169:8;23160:6;;:17;;;;;;;;;;;;;;;;;;23224:8;23193:40;;23214:8;23193:40;;;;;;;;;;;;23113:128;23050:191;:::o;25917:106::-;25975:7;26006:1;26002;:5;:13;;26014:1;26002:13;;;26010:1;26002:13;25995:20;;25917:106;;;;:::o;14906:190::-;15007:81;15027:5;15049;:18;;;15070:4;15076:2;15080:5;15034:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15007:19;:81::i;:::-;14906:190;;;;:::o;48077:625::-;48134:7;48142;48150;48242:19;48263:17;48282;48301:15;;;;;;;;;;;:31;;;48340:9;48373:11;;;;;;;;;;;48416:6;48457:1;48500;48551:4;48606:15;48301:331;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48241:391;;;;;;48653:11;48665:9;48675;48645:40;;;;;;;;;48077:625;;;;;:::o;17310:638::-;17734:23;17760:33;17788:4;17768:5;17760:27;;;;:33;;;;:::i;:::-;17734:59;;17829:1;17808:10;:17;:22;;:57;;;;;17846:10;17835:30;;;;;;;;;;;;:::i;:::-;17834:31;17808:57;17804:137;;;17922:5;17889:40;;;;;;;;;;;:::i;:::-;;;;;;;;17804:137;17380:568;17310:638;;:::o;19746:98::-;19799:7;19826:10;19819:17;;19746:98;:::o;2797:153::-;2872:12;2904:38;2926:6;2934:4;2940:1;2904:21;:38::i;:::-;2897:45;;2797:153;;;;:::o;3285:398::-;3384:12;3437:5;3413:21;:29;3409:110;;;3501:4;3466:41;;;;;;;;;;;:::i;:::-;;;;;;;;3409:110;3530:12;3544:23;3571:6;:11;;3590:5;3597:4;3571:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3529:73;;;;3620:55;3647:6;3655:7;3664:10;3620:26;:55::i;:::-;3613:62;;;;3285:398;;;;;:::o;4761:597::-;4909:12;4939:7;4934:417;;4963:19;4971:10;4963:7;:19::i;:::-;4934:417;;;5212:1;5191:10;:17;:22;:49;;;;;5239:1;5217:6;:18;;;:23;5191:49;5187:121;;;5285:6;5268:24;;;;;;;;;;;:::i;:::-;;;;;;;;5187:121;5329:10;5322:17;;;;4934:417;4761:597;;;;;;:::o;5911:528::-;6064:1;6044:10;:17;:21;6040:392;;;6276:10;6270:17;6333:15;6320:10;6316:2;6312:19;6305:44;6040:392;6403:17;;;;;;;;;;;;;;88:117:1;197:1;194;187:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:77::-;1213:7;1242:5;1231:16;;1176:77;;;:::o;1259:118::-;1346:24;1364:5;1346:24;:::i;:::-;1341:3;1334:37;1259:118;;:::o;1383:222::-;1476:4;1514:2;1503:9;1499:18;1491:26;;1527:71;1595:1;1584:9;1580:17;1571:6;1527:71;:::i;:::-;1383:222;;;;:::o;1611:118::-;1698:24;1716:5;1698:24;:::i;:::-;1693:3;1686:37;1611:118;;:::o;1735:222::-;1828:4;1866:2;1855:9;1851:18;1843:26;;1879:71;1947:1;1936:9;1932:17;1923:6;1879:71;:::i;:::-;1735:222;;;;:::o;1963:122::-;2036:24;2054:5;2036:24;:::i;:::-;2029:5;2026:35;2016:63;;2075:1;2072;2065:12;2016:63;1963:122;:::o;2091:139::-;2137:5;2175:6;2162:20;2153:29;;2191:33;2218:5;2191:33;:::i;:::-;2091:139;;;;:::o;2236:329::-;2295:6;2344:2;2332:9;2323:7;2319:23;2315:32;2312:119;;;2350:79;;:::i;:::-;2312:119;2470:1;2495:53;2540:7;2531:6;2520:9;2516:22;2495:53;:::i;:::-;2485:63;;2441:117;2236:329;;;;:::o;2571:332::-;2692:4;2730:2;2719:9;2715:18;2707:26;;2743:71;2811:1;2800:9;2796:17;2787:6;2743:71;:::i;:::-;2824:72;2892:2;2881:9;2877:18;2868:6;2824:72;:::i;:::-;2571:332;;;;;:::o;2909:60::-;2937:3;2958:5;2951:12;;2909:60;;;:::o;2975:142::-;3025:9;3058:53;3076:34;3085:24;3103:5;3085:24;:::i;:::-;3076:34;:::i;:::-;3058:53;:::i;:::-;3045:66;;2975:142;;;:::o;3123:126::-;3173:9;3206:37;3237:5;3206:37;:::i;:::-;3193:50;;3123:126;;;:::o;3255:140::-;3319:9;3352:37;3383:5;3352:37;:::i;:::-;3339:50;;3255:140;;;:::o;3401:159::-;3502:51;3547:5;3502:51;:::i;:::-;3497:3;3490:64;3401:159;;:::o;3566:250::-;3673:4;3711:2;3700:9;3696:18;3688:26;;3724:85;3806:1;3795:9;3791:17;3782:6;3724:85;:::i;:::-;3566:250;;;;:::o;3822:474::-;3890:6;3898;3947:2;3935:9;3926:7;3922:23;3918:32;3915:119;;;3953:79;;:::i;:::-;3915:119;4073:1;4098:53;4143:7;4134:6;4123:9;4119:22;4098:53;:::i;:::-;4088:63;;4044:117;4200:2;4226:53;4271:7;4262:6;4251:9;4247:22;4226:53;:::i;:::-;4216:63;;4171:118;3822:474;;;;;:::o;4302:::-;4370:6;4378;4427:2;4415:9;4406:7;4402:23;4398:32;4395:119;;;4433:79;;:::i;:::-;4395:119;4553:1;4578:53;4623:7;4614:6;4603:9;4599:22;4578:53;:::i;:::-;4568:63;;4524:117;4680:2;4706:53;4751:7;4742:6;4731:9;4727:22;4706:53;:::i;:::-;4696:63;;4651:118;4302:474;;;;;:::o;4782:180::-;4830:77;4827:1;4820:88;4927:4;4924:1;4917:15;4951:4;4948:1;4941:15;4968:194;5008:4;5028:20;5046:1;5028:20;:::i;:::-;5023:25;;5062:20;5080:1;5062:20;:::i;:::-;5057:25;;5106:1;5103;5099:9;5091:17;;5130:1;5124:4;5121:11;5118:37;;;5135:18;;:::i;:::-;5118:37;4968:194;;;;:::o;5168:410::-;5208:7;5231:20;5249:1;5231:20;:::i;:::-;5226:25;;5265:20;5283:1;5265:20;:::i;:::-;5260:25;;5320:1;5317;5313:9;5342:30;5360:11;5342:30;:::i;:::-;5331:41;;5521:1;5512:7;5508:15;5505:1;5502:22;5482:1;5475:9;5455:83;5432:139;;5551:18;;:::i;:::-;5432:139;5216:362;5168:410;;;;:::o;5584:180::-;5632:77;5629:1;5622:88;5729:4;5726:1;5719:15;5753:4;5750:1;5743:15;5770:185;5810:1;5827:20;5845:1;5827:20;:::i;:::-;5822:25;;5861:20;5879:1;5861:20;:::i;:::-;5856:25;;5900:1;5890:35;;5905:18;;:::i;:::-;5890:35;5947:1;5944;5940:9;5935:14;;5770:185;;;;:::o;5961:191::-;6001:3;6020:20;6038:1;6020:20;:::i;:::-;6015:25;;6054:20;6072:1;6054:20;:::i;:::-;6049:25;;6097:1;6094;6090:9;6083:16;;6118:3;6115:1;6112:10;6109:36;;;6125:18;;:::i;:::-;6109:36;5961:191;;;;:::o;6158:169::-;6242:11;6276:6;6271:3;6264:19;6316:4;6311:3;6307:14;6292:29;;6158:169;;;;:::o;6333:225::-;6473:34;6469:1;6461:6;6457:14;6450:58;6542:8;6537:2;6529:6;6525:15;6518:33;6333:225;:::o;6564:366::-;6706:3;6727:67;6791:2;6786:3;6727:67;:::i;:::-;6720:74;;6803:93;6892:3;6803:93;:::i;:::-;6921:2;6916:3;6912:12;6905:19;;6564:366;;;:::o;6936:419::-;7102:4;7140:2;7129:9;7125:18;7117:26;;7189:9;7183:4;7179:20;7175:1;7164:9;7160:17;7153:47;7217:131;7343:4;7217:131;:::i;:::-;7209:139;;6936:419;;;:::o;7361:224::-;7501:34;7497:1;7489:6;7485:14;7478:58;7570:7;7565:2;7557:6;7553:15;7546:32;7361:224;:::o;7591:366::-;7733:3;7754:67;7818:2;7813:3;7754:67;:::i;:::-;7747:74;;7830:93;7919:3;7830:93;:::i;:::-;7948:2;7943:3;7939:12;7932:19;;7591:366;;;:::o;7963:419::-;8129:4;8167:2;8156:9;8152:18;8144:26;;8216:9;8210:4;8206:20;8202:1;8191:9;8187:17;8180:47;8244:131;8370:4;8244:131;:::i;:::-;8236:139;;7963:419;;;:::o;8388:177::-;8528:29;8524:1;8516:6;8512:14;8505:53;8388:177;:::o;8571:366::-;8713:3;8734:67;8798:2;8793:3;8734:67;:::i;:::-;8727:74;;8810:93;8899:3;8810:93;:::i;:::-;8928:2;8923:3;8919:12;8912:19;;8571:366;;;:::o;8943:419::-;9109:4;9147:2;9136:9;9132:18;9124:26;;9196:9;9190:4;9186:20;9182:1;9171:9;9167:17;9160:47;9224:131;9350:4;9224:131;:::i;:::-;9216:139;;8943:419;;;:::o;9368:180::-;9508:32;9504:1;9496:6;9492:14;9485:56;9368:180;:::o;9554:366::-;9696:3;9717:67;9781:2;9776:3;9717:67;:::i;:::-;9710:74;;9793:93;9882:3;9793:93;:::i;:::-;9911:2;9906:3;9902:12;9895:19;;9554:366;;;:::o;9926:419::-;10092:4;10130:2;10119:9;10115:18;10107:26;;10179:9;10173:4;10169:20;10165:1;10154:9;10150:17;10143:47;10207:131;10333:4;10207:131;:::i;:::-;10199:139;;9926:419;;;:::o;10351:182::-;10491:34;10487:1;10479:6;10475:14;10468:58;10351:182;:::o;10539:366::-;10681:3;10702:67;10766:2;10761:3;10702:67;:::i;:::-;10695:74;;10778:93;10867:3;10778:93;:::i;:::-;10896:2;10891:3;10887:12;10880:19;;10539:366;;;:::o;10911:419::-;11077:4;11115:2;11104:9;11100:18;11092:26;;11164:9;11158:4;11154:20;11150:1;11139:9;11135:17;11128:47;11192:131;11318:4;11192:131;:::i;:::-;11184:139;;10911:419;;;:::o;11336:332::-;11457:4;11495:2;11484:9;11480:18;11472:26;;11508:71;11576:1;11565:9;11561:17;11552:6;11508:71;:::i;:::-;11589:72;11657:2;11646:9;11642:18;11633:6;11589:72;:::i;:::-;11336:332;;;;;:::o;11674:90::-;11708:7;11751:5;11744:13;11737:21;11726:32;;11674:90;;;:::o;11770:116::-;11840:21;11855:5;11840:21;:::i;:::-;11833:5;11830:32;11820:60;;11876:1;11873;11866:12;11820:60;11770:116;:::o;11892:137::-;11946:5;11977:6;11971:13;11962:22;;11993:30;12017:5;11993:30;:::i;:::-;11892:137;;;;:::o;12035:345::-;12102:6;12151:2;12139:9;12130:7;12126:23;12122:32;12119:119;;;12157:79;;:::i;:::-;12119:119;12277:1;12302:61;12355:7;12346:6;12335:9;12331:22;12302:61;:::i;:::-;12292:71;;12248:125;12035:345;;;;:::o;12386:164::-;12526:16;12522:1;12514:6;12510:14;12503:40;12386:164;:::o;12556:366::-;12698:3;12719:67;12783:2;12778:3;12719:67;:::i;:::-;12712:74;;12795:93;12884:3;12795:93;:::i;:::-;12913:2;12908:3;12904:12;12897:19;;12556:366;;;:::o;12928:419::-;13094:4;13132:2;13121:9;13117:18;13109:26;;13181:9;13175:4;13171:20;13167:1;13156:9;13152:17;13145:47;13209:131;13335:4;13209:131;:::i;:::-;13201:139;;12928:419;;;:::o;13353:179::-;13493:31;13489:1;13481:6;13477:14;13470:55;13353:179;:::o;13538:366::-;13680:3;13701:67;13765:2;13760:3;13701:67;:::i;:::-;13694:74;;13777:93;13866:3;13777:93;:::i;:::-;13895:2;13890:3;13886:12;13879:19;;13538:366;;;:::o;13910:419::-;14076:4;14114:2;14103:9;14099:18;14091:26;;14163:9;14157:4;14153:20;14149:1;14138:9;14134:17;14127:47;14191:131;14317:4;14191:131;:::i;:::-;14183:139;;13910:419;;;:::o;14335:147::-;14436:11;14473:3;14458:18;;14335:147;;;;:::o;14488:114::-;;:::o;14608:398::-;14767:3;14788:83;14869:1;14864:3;14788:83;:::i;:::-;14781:90;;14880:93;14969:3;14880:93;:::i;:::-;14998:1;14993:3;14989:11;14982:18;;14608:398;;;:::o;15012:379::-;15196:3;15218:147;15361:3;15218:147;:::i;:::-;15211:154;;15382:3;15375:10;;15012:379;;;:::o;15397:245::-;15537:34;15533:1;15525:6;15521:14;15514:58;15606:28;15601:2;15593:6;15589:15;15582:53;15397:245;:::o;15648:366::-;15790:3;15811:67;15875:2;15870:3;15811:67;:::i;:::-;15804:74;;15887:93;15976:3;15887:93;:::i;:::-;16005:2;16000:3;15996:12;15989:19;;15648:366;;;:::o;16020:419::-;16186:4;16224:2;16213:9;16209:18;16201:26;;16273:9;16267:4;16263:20;16259:1;16248:9;16244:17;16237:47;16301:131;16427:4;16301:131;:::i;:::-;16293:139;;16020:419;;;:::o;16445:442::-;16594:4;16632:2;16621:9;16617:18;16609:26;;16645:71;16713:1;16702:9;16698:17;16689:6;16645:71;:::i;:::-;16726:72;16794:2;16783:9;16779:18;16770:6;16726:72;:::i;:::-;16808;16876:2;16865:9;16861:18;16852:6;16808:72;:::i;:::-;16445:442;;;;;;:::o;16893:85::-;16938:7;16967:5;16956:16;;16893:85;;;:::o;16984:158::-;17042:9;17075:61;17093:42;17102:32;17128:5;17102:32;:::i;:::-;17093:42;:::i;:::-;17075:61;:::i;:::-;17062:74;;16984:158;;;:::o;17148:147::-;17243:45;17282:5;17243:45;:::i;:::-;17238:3;17231:58;17148:147;;:::o;17301:807::-;17550:4;17588:3;17577:9;17573:19;17565:27;;17602:71;17670:1;17659:9;17655:17;17646:6;17602:71;:::i;:::-;17683:72;17751:2;17740:9;17736:18;17727:6;17683:72;:::i;:::-;17765:80;17841:2;17830:9;17826:18;17817:6;17765:80;:::i;:::-;17855;17931:2;17920:9;17916:18;17907:6;17855:80;:::i;:::-;17945:73;18013:3;18002:9;17998:19;17989:6;17945:73;:::i;:::-;18028;18096:3;18085:9;18081:19;18072:6;18028:73;:::i;:::-;17301:807;;;;;;;;;:::o;18114:143::-;18171:5;18202:6;18196:13;18187:22;;18218:33;18245:5;18218:33;:::i;:::-;18114:143;;;;:::o;18263:663::-;18351:6;18359;18367;18416:2;18404:9;18395:7;18391:23;18387:32;18384:119;;;18422:79;;:::i;:::-;18384:119;18542:1;18567:64;18623:7;18614:6;18603:9;18599:22;18567:64;:::i;:::-;18557:74;;18513:128;18680:2;18706:64;18762:7;18753:6;18742:9;18738:22;18706:64;:::i;:::-;18696:74;;18651:129;18819:2;18845:64;18901:7;18892:6;18881:9;18877:22;18845:64;:::i;:::-;18835:74;;18790:129;18263:663;;;;;:::o;18932:98::-;18983:6;19017:5;19011:12;19001:22;;18932:98;;;:::o;19036:246::-;19117:1;19127:113;19141:6;19138:1;19135:13;19127:113;;;19226:1;19221:3;19217:11;19211:18;19207:1;19202:3;19198:11;19191:39;19163:2;19160:1;19156:10;19151:15;;19127:113;;;19274:1;19265:6;19260:3;19256:16;19249:27;19098:184;19036:246;;;:::o;19288:386::-;19392:3;19420:38;19452:5;19420:38;:::i;:::-;19474:88;19555:6;19550:3;19474:88;:::i;:::-;19467:95;;19571:65;19629:6;19624:3;19617:4;19610:5;19606:16;19571:65;:::i;:::-;19661:6;19656:3;19652:16;19645:23;;19396:278;19288:386;;;;:::o;19680:271::-;19810:3;19832:93;19921:3;19912:6;19832:93;:::i;:::-;19825:100;;19942:3;19935:10;;19680:271;;;;:::o

ipfs://d14f25aec609e2555eb354fb366f73449d4f73c5adcfc97f23fbe318469c81af