Contract 0xf02544CE2eb8806ae83aaBb7B64aB6D8d614e358 14

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

import "./SafeERC20.sol";
import "./IERC20.sol";
import "./SafeMath.sol";

contract stakingPlatform{

    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address public owner;

    struct Users{
        uint256 amount;
        uint256 stakeTime;
        uint claimTime;
    }

    struct stakingPools{
        IERC20 stakingToken;
        IERC20 rewardToken;
        uint stakingTokenDecimals;
        uint rewardTokenDecimals;
        uint256 ratio; //1000000000000000000 * stakingToken / rewardToken
        uint APY;
        uint stakers;
        uint256 totalStaked;
        uint lockDays;
        uint earlyUnstakePenalty;
        mapping(address => Users) users;
    }

    mapping(uint => stakingPools) public sTOKENs;

    constructor(){        
        addToken(0, 6, 6, 0x38c2fBdF53b451Ae5c4027711D6Fe5E1B2191B1C, 0x38c2fBdF53b451Ae5c4027711D6Fe5E1B2191B1C, 1000000000000000000, 112, 0, 0); //AIA -> AIA
        addToken(1, 6, 18, 0x38c2fBdF53b451Ae5c4027711D6Fe5E1B2191B1C, 0x912CE59144191C1204E64559FE8253a0e49E6548, 485300, 100, 0, 0); //AIA -> ARB
        addToken(2, 18, 6, 0x912CE59144191C1204E64559FE8253a0e49E6548, 0x38c2fBdF53b451Ae5c4027711D6Fe5E1B2191B1C, 2060282334986 * 10**18, 122, 0, 0); //ARB -> AIA
    }

    function stakeToken(uint _poolID, uint256 _amount) public {
        stakingPools storage sToken = sTOKENs[_poolID];
        require(_amount > 0, "Amount should be greater than 0");
        if(sToken.users[_msgSender()].amount == 0){
            sToken.stakers++;
        }else{
            claimRewards(_poolID);
        }

        sToken.users[_msgSender()].stakeTime = block.timestamp;
        sToken.users[_msgSender()].claimTime = block.timestamp;
        sToken.users[_msgSender()].amount = sToken.users[_msgSender()].amount.add(_amount);
        sToken.totalStaked = sToken.totalStaked.add(_amount);
        
        
        sToken.stakingToken.safeTransferFrom(_msgSender(), address(this), _amount);
    }

    function unstakeToken(uint _poolID) public {
        stakingPools storage sToken = sTOKENs[_poolID];
        require(sToken.users[_msgSender()].amount > 0, "No active stake!");

        if((block.timestamp - sToken.users[_msgSender()].stakeTime) / 60 / 60 / 24 >= sToken.lockDays){
            uint256 _amount = sToken.users[_msgSender()].amount;
            sToken.users[_msgSender()].amount = 0;
            sToken.totalStaked -= _amount;
            sToken.stakingToken.safeTransfer(_msgSender(), _amount);
        }else{
            uint256 _amount = sToken.users[_msgSender()].amount;
            sToken.users[_msgSender()].amount = 0;
            sToken.totalStaked -= _amount;
            sToken.stakingToken.safeTransfer(_msgSender(), getPercent(_amount, (100 - sToken.earlyUnstakePenalty)));
        }
        sToken.users[_msgSender()].stakeTime = 0;
        sToken.stakers--;
    }

    function claimRewards(uint _poolID) public {
        stakingPools storage sToken = sTOKENs[_poolID];
        require(sToken.users[_msgSender()].amount > 0, "No active stake!");

        uint256 pft = ((getPercent(sToken.users[_msgSender()].amount, sToken.APY) * (block.timestamp - sToken.users[_msgSender()].claimTime)) / 60 / 60 / 24) / 365;
        pft = (pft * sToken.ratio * (10**sToken.rewardTokenDecimals) / (10**sToken.stakingTokenDecimals)) / (10**18);
        
        sToken.users[_msgSender()].claimTime = block.timestamp;

        sToken.rewardToken.safeTransfer(_msgSender(), pft);
    }

    function getData(uint _poolID, address _user) public view returns(uint, uint256, uint256, uint256){
        stakingPools storage sToken = sTOKENs[_poolID];
        return(sToken.stakers, sToken.users[_user].amount, sToken.users[_user].stakeTime, sToken.users[_user].claimTime);
    }

    // Add a new token to stake
    function addToken(uint _poolID,
                    uint _stakingTKNdecimal,
                    uint _rewardTKNdecimal,
                    address _stakingTKNadr,
                    address _rewardTKNadr,
                    uint256 _ratio,
                    uint _APY,
                    uint _lockDays,
                    uint _earlyUnstakePenalty)
                    private{
        require(sTOKENs[_poolID].ratio == 0, "Token already exists");

        stakingPools storage sToken = sTOKENs[_poolID];
        sToken.stakingTokenDecimals = _stakingTKNdecimal;
        sToken.rewardTokenDecimals = _rewardTKNdecimal;
        sToken.stakingToken = IERC20(_stakingTKNadr);
        sToken.rewardToken = IERC20(_rewardTKNadr);
        sToken.ratio = _ratio;
        sToken.APY = _APY;
        sToken.lockDays = _lockDays;
        sToken.earlyUnstakePenalty = _earlyUnstakePenalty;

    }

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

    function getPercent(uint256 _val, uint _percent) internal pure  returns (uint256) {
        uint vald;
        vald = (_val * _percent) / 100 ;
        return vald;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.0;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `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);

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./SafeMath.sol";
import "./Address.sol";

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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 substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

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

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

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

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

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

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

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

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

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

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

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

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"_poolID","type":"uint256"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_poolID","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"getData","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"sTOKENs","outputs":[{"internalType":"contract IERC20","name":"stakingToken","type":"address"},{"internalType":"contract IERC20","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"stakingTokenDecimals","type":"uint256"},{"internalType":"uint256","name":"rewardTokenDecimals","type":"uint256"},{"internalType":"uint256","name":"ratio","type":"uint256"},{"internalType":"uint256","name":"APY","type":"uint256"},{"internalType":"uint256","name":"stakers","type":"uint256"},{"internalType":"uint256","name":"totalStaked","type":"uint256"},{"internalType":"uint256","name":"lockDays","type":"uint256"},{"internalType":"uint256","name":"earlyUnstakePenalty","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_poolID","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stakeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_poolID","type":"uint256"}],"name":"unstakeToken","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

132:4897:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2928:600;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2030:892;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3534:283;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;228:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;754:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;1311:713;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2928:600;2981:27;3011:7;:16;3019:7;3011:16;;;;;;;;;;;2981:46;;3081:1;3045:6;:12;;:26;3058:12;:10;:12::i;:::-;3045:26;;;;;;;;;;;;;;;:33;;;:37;3037:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;3114:11;3266:3;3260:2;3255;3250;3209:6;:12;;:26;3222:12;:10;:12::i;:::-;3209:26;;;;;;;;;;;;;;;:36;;;3191:15;:54;;;;:::i;:::-;3130:57;3141:6;:12;;:26;3154:12;:10;:12::i;:::-;3141:26;;;;;;;;;;;;;;;:33;;;3176:6;:10;;;3130;:57::i;:::-;:116;;;;:::i;:::-;3129:123;;;;:::i;:::-;:128;;;;:::i;:::-;:133;;;;:::i;:::-;3128:141;;;;:::i;:::-;3114:155;;3380:6;3347;:27;;;3343:2;:31;;;;:::i;:::-;3312:6;:26;;;3308:2;:30;;;;:::i;:::-;3292:6;:12;;;3286:3;:18;;;;:::i;:::-;:53;;;;:::i;:::-;:89;;;;:::i;:::-;3285:102;;;;:::i;:::-;3279:108;;3445:15;3406:6;:12;;:26;3419:12;:10;:12::i;:::-;3406:26;;;;;;;;;;;;;;;:36;;:54;;;;3471:50;3503:12;:10;:12::i;:::-;3517:3;3471:6;:18;;;;;;;;;;;;:31;;;;:50;;;;;:::i;:::-;2971:557;;2928:600;:::o;2030:892::-;2083:27;2113:7;:16;2121:7;2113:16;;;;;;;;;;;2083:46;;2183:1;2147:6;:12;;:26;2160:12;:10;:12::i;:::-;2147:26;;;;;;;;;;;;;;;:33;;;:37;2139:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;2294:6;:15;;;2288:2;2283;2278;2238:6;:12;;:26;2251:12;:10;:12::i;:::-;2238:26;;;;;;;;;;;;;;;:36;;;2220:15;:54;;;;:::i;:::-;2219:61;;;;:::i;:::-;:66;;;;:::i;:::-;:71;;;;:::i;:::-;:90;2216:624;;2324:15;2342:6;:12;;:26;2355:12;:10;:12::i;:::-;2342:26;;;;;;;;;;;;;;;:33;;;2324:51;;2425:1;2389:6;:12;;:26;2402:12;:10;:12::i;:::-;2389:26;;;;;;;;;;;;;;;:33;;:37;;;;2462:7;2440:6;:18;;;:29;;;;;;;:::i;:::-;;;;;;;;2483:55;2516:12;:10;:12::i;:::-;2530:7;2483:6;:19;;;;;;;;;;;;:32;;;;:55;;;;;:::i;:::-;2310:239;2216:624;;;2567:15;2585:6;:12;;:26;2598:12;:10;:12::i;:::-;2585:26;;;;;;;;;;;;;;;:33;;;2567:51;;2668:1;2632:6;:12;;:26;2645:12;:10;:12::i;:::-;2632:26;;;;;;;;;;;;;;;:33;;:37;;;;2705:7;2683:6;:18;;;:29;;;;;;;:::i;:::-;;;;;;;;2726:103;2759:12;:10;:12::i;:::-;2773:55;2784:7;2800:6;:26;;;2794:3;:32;;;;:::i;:::-;2773:10;:55::i;:::-;2726:6;:19;;;;;;;;;;;;:32;;;;:103;;;;;:::i;:::-;2553:287;2216:624;2888:1;2849:6;:12;;:26;2862:12;:10;:12::i;:::-;2849:26;;;;;;;;;;;;;;;:36;;:40;;;;2899:6;:14;;;:16;;;;;;;;;:::i;:::-;;;;;;2073:849;2030:892;:::o;3534:283::-;3600:4;3606:7;3615;3624;3642:27;3672:7;:16;3680:7;3672:16;;;;;;;;;;;3642:46;;3705:6;:14;;;3721:6;:12;;:19;3734:5;3721:19;;;;;;;;;;;;;;;:26;;;3749:6;:12;;:19;3762:5;3749:19;;;;;;;;;;;;;;;:29;;;3780:6;:12;;:19;3793:5;3780:19;;;;;;;;;;;;;;;:29;;;3698:112;;;;;;;;;3534:283;;;;;;;:::o;228:20::-;;;;;;;;;;;;:::o;754:44::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1311:713::-;1379:27;1409:7;:16;1417:7;1409:16;;;;;;;;;;;1379:46;;1453:1;1443:7;:11;1435:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;1540:1;1503:6;:12;;:26;1516:12;:10;:12::i;:::-;1503:26;;;;;;;;;;;;;;;:33;;;:38;1500:133;;1556:6;:14;;;:16;;;;;;;;;:::i;:::-;;;;;;1500:133;;;1601:21;1614:7;1601:12;:21::i;:::-;1500:133;1682:15;1643:6;:12;;:26;1656:12;:10;:12::i;:::-;1643:26;;;;;;;;;;;;;;;:36;;:54;;;;1746:15;1707:6;:12;;:26;1720:12;:10;:12::i;:::-;1707:26;;;;;;;;;;;;;;;:36;;:54;;;;1807:46;1845:7;1807:6;:12;;:26;1820:12;:10;:12::i;:::-;1807:26;;;;;;;;;;;;;;;:33;;;:37;;:46;;;;:::i;:::-;1771:6;:12;;:26;1784:12;:10;:12::i;:::-;1771:26;;;;;;;;;;;;;;;:33;;:82;;;;1884:31;1907:7;1884:6;:18;;;:22;;:31;;;;:::i;:::-;1863:6;:18;;:52;;;;1943:74;1980:12;:10;:12::i;:::-;2002:4;2009:7;1943:6;:19;;;;;;;;;;;;:36;;;;:74;;;;;;:::i;:::-;1369:655;1311:713;;:::o;4755:96::-;4808:7;4834:10;4827:17;;4755:96;:::o;4857:170::-;4930:7;4949:9;4995:3;4983:8;4976:4;:15;;;;:::i;:::-;4975:23;;;;:::i;:::-;4968:30;;5016:4;5009:11;;;4857:170;;;;:::o;712:205:2:-;824:86;844:5;874:23;;;899:2;903:5;851:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;824:19;:86::i;:::-;712:205;;;:::o;2741:96:3:-;2799:7;2829:1;2825;:5;;;;:::i;:::-;2818:12;;2741:96;;;;:::o;923:241:2:-;1061:96;1081:5;1111:27;;;1140:4;1146:2;1150:5;1088:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1061:19;:96::i;:::-;923:241;;;;:::o;3218:706::-;3637:23;3663:69;3691:4;3663:69;;;;;;;;;;;;;;;;;3671:5;3663:27;;;;:69;;;;;:::i;:::-;3637:95;;3766:1;3746:10;:17;:21;3742:176;;;3841:10;3830:30;;;;;;;;;;;;:::i;:::-;3822:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;3742:176;3288:636;3218:706;;:::o;3861:223:0:-;3994:12;4025:52;4047:6;4055:4;4061:1;4064:12;4025:21;:52::i;:::-;4018:59;;3861:223;;;;;:::o;4948:499::-;5113:12;5170:5;5145:21;:30;;5137:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;5236:18;5247:6;5236:10;:18::i;:::-;5228:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;5300:12;5314:23;5341:6;:11;;5360:5;5367:4;5341:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5299:73;;;;5389:51;5406:7;5415:10;5427:12;5389:16;:51::i;:::-;5382:58;;;;4948:499;;;;;;:::o;1175:320::-;1235:4;1487:1;1465:7;:19;;;:23;1458:30;;1175:320;;;:::o;7561:692::-;7707:12;7735:7;7731:516;;;7765:10;7758:17;;;;7731:516;7896:1;7876:10;:17;:21;7872:365;;;8070:10;8064:17;8130:15;8117:10;8113:2;8109:19;8102:44;7872:365;8209:12;8202:20;;;;;;;;;;;:::i;:::-;;;;;;;;7561:692;;;;;;:::o;88:117:5:-;197:1;194;187:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:126::-;1062:7;1102:42;1095:5;1091:54;1080:65;;1025:126;;;:::o;1157:96::-;1194:7;1223:24;1241:5;1223:24;:::i;:::-;1212:35;;1157:96;;;:::o;1259:122::-;1332:24;1350:5;1332:24;:::i;:::-;1325:5;1322:35;1312:63;;1371:1;1368;1361:12;1312:63;1259:122;:::o;1387:139::-;1433:5;1471:6;1458:20;1449:29;;1487:33;1514:5;1487:33;:::i;:::-;1387:139;;;;:::o;1532:474::-;1600:6;1608;1657:2;1645:9;1636:7;1632:23;1628:32;1625:119;;;1663:79;;:::i;:::-;1625:119;1783:1;1808:53;1853:7;1844:6;1833:9;1829:22;1808:53;:::i;:::-;1798:63;;1754:117;1910:2;1936:53;1981:7;1972:6;1961:9;1957:22;1936:53;:::i;:::-;1926:63;;1881:118;1532:474;;;;;:::o;2012:118::-;2099:24;2117:5;2099:24;:::i;:::-;2094:3;2087:37;2012:118;;:::o;2136:553::-;2313:4;2351:3;2340:9;2336:19;2328:27;;2365:71;2433:1;2422:9;2418:17;2409:6;2365:71;:::i;:::-;2446:72;2514:2;2503:9;2499:18;2490:6;2446:72;:::i;:::-;2528;2596:2;2585:9;2581:18;2572:6;2528:72;:::i;:::-;2610;2678:2;2667:9;2663:18;2654:6;2610:72;:::i;:::-;2136:553;;;;;;;:::o;2695:118::-;2782:24;2800:5;2782:24;:::i;:::-;2777:3;2770:37;2695:118;;:::o;2819:222::-;2912:4;2950:2;2939:9;2935:18;2927:26;;2963:71;3031:1;3020:9;3016:17;3007:6;2963:71;:::i;:::-;2819:222;;;;:::o;3047:60::-;3075:3;3096:5;3089:12;;3047:60;;;:::o;3113:142::-;3163:9;3196:53;3214:34;3223:24;3241:5;3223:24;:::i;:::-;3214:34;:::i;:::-;3196:53;:::i;:::-;3183:66;;3113:142;;;:::o;3261:126::-;3311:9;3344:37;3375:5;3344:37;:::i;:::-;3331:50;;3261:126;;;:::o;3393:140::-;3457:9;3490:37;3521:5;3490:37;:::i;:::-;3477:50;;3393:140;;;:::o;3539:159::-;3640:51;3685:5;3640:51;:::i;:::-;3635:3;3628:64;3539:159;;:::o;3704:1275::-;4077:4;4115:3;4104:9;4100:19;4092:27;;4129:85;4211:1;4200:9;4196:17;4187:6;4129:85;:::i;:::-;4224:86;4306:2;4295:9;4291:18;4282:6;4224:86;:::i;:::-;4320:72;4388:2;4377:9;4373:18;4364:6;4320:72;:::i;:::-;4402;4470:2;4459:9;4455:18;4446:6;4402:72;:::i;:::-;4484:73;4552:3;4541:9;4537:19;4528:6;4484:73;:::i;:::-;4567;4635:3;4624:9;4620:19;4611:6;4567:73;:::i;:::-;4650;4718:3;4707:9;4703:19;4694:6;4650:73;:::i;:::-;4733;4801:3;4790:9;4786:19;4777:6;4733:73;:::i;:::-;4816;4884:3;4873:9;4869:19;4860:6;4816:73;:::i;:::-;4899;4967:3;4956:9;4952:19;4943:6;4899:73;:::i;:::-;3704:1275;;;;;;;;;;;;;:::o;4985:474::-;5053:6;5061;5110:2;5098:9;5089:7;5085:23;5081:32;5078:119;;;5116:79;;:::i;:::-;5078:119;5236:1;5261:53;5306:7;5297:6;5286:9;5282:22;5261:53;:::i;:::-;5251:63;;5207:117;5363:2;5389:53;5434:7;5425:6;5414:9;5410:22;5389:53;:::i;:::-;5379:63;;5334:118;4985:474;;;;;:::o;5465:169::-;5549:11;5583:6;5578:3;5571:19;5623:4;5618:3;5614:14;5599:29;;5465:169;;;;:::o;5640:166::-;5780:18;5776:1;5768:6;5764:14;5757:42;5640:166;:::o;5812:366::-;5954:3;5975:67;6039:2;6034:3;5975:67;:::i;:::-;5968:74;;6051:93;6140:3;6051:93;:::i;:::-;6169:2;6164:3;6160:12;6153:19;;5812:366;;;:::o;6184:419::-;6350:4;6388:2;6377:9;6373:18;6365:26;;6437:9;6431:4;6427:20;6423:1;6412:9;6408:17;6401:47;6465:131;6591:4;6465:131;:::i;:::-;6457:139;;6184:419;;;:::o;6609:180::-;6657:77;6654:1;6647:88;6754:4;6751:1;6744:15;6778:4;6775:1;6768:15;6795:194;6835:4;6855:20;6873:1;6855:20;:::i;:::-;6850:25;;6889:20;6907:1;6889:20;:::i;:::-;6884:25;;6933:1;6930;6926:9;6918:17;;6957:1;6951:4;6948:11;6945:37;;;6962:18;;:::i;:::-;6945:37;6795:194;;;;:::o;6995:410::-;7035:7;7058:20;7076:1;7058:20;:::i;:::-;7053:25;;7092:20;7110:1;7092:20;:::i;:::-;7087:25;;7147:1;7144;7140:9;7169:30;7187:11;7169:30;:::i;:::-;7158:41;;7348:1;7339:7;7335:15;7332:1;7329:22;7309:1;7302:9;7282:83;7259:139;;7378:18;;:::i;:::-;7259:139;7043:362;6995:410;;;;:::o;7411:180::-;7459:77;7456:1;7449:88;7556:4;7553:1;7546:15;7580:4;7577:1;7570:15;7597:185;7637:1;7654:20;7672:1;7654:20;:::i;:::-;7649:25;;7688:20;7706:1;7688:20;:::i;:::-;7683:25;;7727:1;7717:35;;7732:18;;:::i;:::-;7717:35;7774:1;7771;7767:9;7762:14;;7597:185;;;;:::o;7788:102::-;7830:8;7877:5;7874:1;7870:13;7849:34;;7788:102;;;:::o;7896:848::-;7957:5;7964:4;7988:6;7979:15;;8012:5;8003:14;;8026:712;8047:1;8037:8;8034:15;8026:712;;;8142:4;8137:3;8133:14;8127:4;8124:24;8121:50;;;8151:18;;:::i;:::-;8121:50;8201:1;8191:8;8187:16;8184:451;;;8616:4;8609:5;8605:16;8596:25;;8184:451;8666:4;8660;8656:15;8648:23;;8696:32;8719:8;8696:32;:::i;:::-;8684:44;;8026:712;;;7896:848;;;;;;;:::o;8750:1073::-;8804:5;8995:8;8985:40;;9016:1;9007:10;;9018:5;;8985:40;9044:4;9034:36;;9061:1;9052:10;;9063:5;;9034:36;9130:4;9178:1;9173:27;;;;9214:1;9209:191;;;;9123:277;;9173:27;9191:1;9182:10;;9193:5;;;9209:191;9254:3;9244:8;9241:17;9238:43;;;9261:18;;:::i;:::-;9238:43;9310:8;9307:1;9303:16;9294:25;;9345:3;9338:5;9335:14;9332:40;;;9352:18;;:::i;:::-;9332:40;9385:5;;;9123:277;;9509:2;9499:8;9496:16;9490:3;9484:4;9481:13;9477:36;9459:2;9449:8;9446:16;9441:2;9435:4;9432:12;9428:35;9412:111;9409:246;;;9565:8;9559:4;9555:19;9546:28;;9600:3;9593:5;9590:14;9587:40;;;9607:18;;:::i;:::-;9587:40;9640:5;;9409:246;9680:42;9718:3;9708:8;9702:4;9699:1;9680:42;:::i;:::-;9665:57;;;;9754:4;9749:3;9745:14;9738:5;9735:25;9732:51;;;9763:18;;:::i;:::-;9732:51;9812:4;9805:5;9801:16;9792:25;;8750:1073;;;;;;:::o;9829:285::-;9889:5;9913:23;9931:4;9913:23;:::i;:::-;9905:31;;9957:27;9975:8;9957:27;:::i;:::-;9945:39;;10003:104;10040:66;10030:8;10024:4;10003:104;:::i;:::-;9994:113;;9829:285;;;;:::o;10120:171::-;10159:3;10182:24;10200:5;10182:24;:::i;:::-;10173:33;;10228:4;10221:5;10218:15;10215:41;;10236:18;;:::i;:::-;10215:41;10283:1;10276:5;10272:13;10265:20;;10120:171;;;:::o;10297:181::-;10437:33;10433:1;10425:6;10421:14;10414:57;10297:181;:::o;10484:366::-;10626:3;10647:67;10711:2;10706:3;10647:67;:::i;:::-;10640:74;;10723:93;10812:3;10723:93;:::i;:::-;10841:2;10836:3;10832:12;10825:19;;10484:366;;;:::o;10856:419::-;11022:4;11060:2;11049:9;11045:18;11037:26;;11109:9;11103:4;11099:20;11095:1;11084:9;11080:17;11073:47;11137:131;11263:4;11137:131;:::i;:::-;11129:139;;10856:419;;;:::o;11281:233::-;11320:3;11343:24;11361:5;11343:24;:::i;:::-;11334:33;;11389:66;11382:5;11379:77;11376:103;;11459:18;;:::i;:::-;11376:103;11506:1;11499:5;11495:13;11488:20;;11281:233;;;:::o;11520:332::-;11641:4;11679:2;11668:9;11664:18;11656:26;;11692:71;11760:1;11749:9;11745:17;11736:6;11692:71;:::i;:::-;11773:72;11841:2;11830:9;11826:18;11817:6;11773:72;:::i;:::-;11520:332;;;;;:::o;11858:191::-;11898:3;11917:20;11935:1;11917:20;:::i;:::-;11912:25;;11951:20;11969:1;11951:20;:::i;:::-;11946:25;;11994:1;11991;11987:9;11980:16;;12015:3;12012:1;12009:10;12006:36;;;12022:18;;:::i;:::-;12006:36;11858:191;;;;:::o;12055:442::-;12204:4;12242:2;12231:9;12227:18;12219:26;;12255:71;12323:1;12312:9;12308:17;12299:6;12255:71;:::i;:::-;12336:72;12404:2;12393:9;12389:18;12380:6;12336:72;:::i;:::-;12418;12486:2;12475:9;12471:18;12462:6;12418:72;:::i;:::-;12055:442;;;;;;:::o;12503:90::-;12537:7;12580:5;12573:13;12566:21;12555:32;;12503:90;;;:::o;12599:116::-;12669:21;12684:5;12669:21;:::i;:::-;12662:5;12659:32;12649:60;;12705:1;12702;12695:12;12649:60;12599:116;:::o;12721:137::-;12775:5;12806:6;12800:13;12791:22;;12822:30;12846:5;12822:30;:::i;:::-;12721:137;;;;:::o;12864:345::-;12931:6;12980:2;12968:9;12959:7;12955:23;12951:32;12948:119;;;12986:79;;:::i;:::-;12948:119;13106:1;13131:61;13184:7;13175:6;13164:9;13160:22;13131:61;:::i;:::-;13121:71;;13077:125;12864:345;;;;:::o;13215:229::-;13355:34;13351:1;13343:6;13339:14;13332:58;13424:12;13419:2;13411:6;13407:15;13400:37;13215:229;:::o;13450:366::-;13592:3;13613:67;13677:2;13672:3;13613:67;:::i;:::-;13606:74;;13689:93;13778:3;13689:93;:::i;:::-;13807:2;13802:3;13798:12;13791:19;;13450:366;;;:::o;13822:419::-;13988:4;14026:2;14015:9;14011:18;14003:26;;14075:9;14069:4;14065:20;14061:1;14050:9;14046:17;14039:47;14103:131;14229:4;14103:131;:::i;:::-;14095:139;;13822:419;;;:::o;14247:225::-;14387:34;14383:1;14375:6;14371:14;14364:58;14456:8;14451:2;14443:6;14439:15;14432:33;14247:225;:::o;14478:366::-;14620:3;14641:67;14705:2;14700:3;14641:67;:::i;:::-;14634:74;;14717:93;14806:3;14717:93;:::i;:::-;14835:2;14830:3;14826:12;14819:19;;14478:366;;;:::o;14850:419::-;15016:4;15054:2;15043:9;15039:18;15031:26;;15103:9;15097:4;15093:20;15089:1;15078:9;15074:17;15067:47;15131:131;15257:4;15131:131;:::i;:::-;15123:139;;14850:419;;;:::o;15275:179::-;15415:31;15411:1;15403:6;15399:14;15392:55;15275:179;:::o;15460:366::-;15602:3;15623:67;15687:2;15682:3;15623:67;:::i;:::-;15616:74;;15699:93;15788:3;15699:93;:::i;:::-;15817:2;15812:3;15808:12;15801:19;;15460:366;;;:::o;15832:419::-;15998:4;16036:2;16025:9;16021:18;16013:26;;16085:9;16079:4;16075:20;16071:1;16060:9;16056:17;16049:47;16113:131;16239:4;16113:131;:::i;:::-;16105:139;;15832:419;;;:::o;16257:98::-;16308:6;16342:5;16336:12;16326:22;;16257:98;;;:::o;16361:147::-;16462:11;16499:3;16484:18;;16361:147;;;;:::o;16514:246::-;16595:1;16605:113;16619:6;16616:1;16613:13;16605:113;;;16704:1;16699:3;16695:11;16689:18;16685:1;16680:3;16676:11;16669:39;16641:2;16638:1;16634:10;16629:15;;16605:113;;;16752:1;16743:6;16738:3;16734:16;16727:27;16576:184;16514:246;;;:::o;16766:386::-;16870:3;16898:38;16930:5;16898:38;:::i;:::-;16952:88;17033:6;17028:3;16952:88;:::i;:::-;16945:95;;17049:65;17107:6;17102:3;17095:4;17088:5;17084:16;17049:65;:::i;:::-;17139:6;17134:3;17130:16;17123:23;;16874:278;16766:386;;;;:::o;17158:271::-;17288:3;17310:93;17399:3;17390:6;17310:93;:::i;:::-;17303:100;;17420:3;17413:10;;17158:271;;;;:::o;17435:99::-;17487:6;17521:5;17515:12;17505:22;;17435:99;;;:::o;17540:102::-;17581:6;17632:2;17628:7;17623:2;17616:5;17612:14;17608:28;17598:38;;17540:102;;;:::o;17648:377::-;17736:3;17764:39;17797:5;17764:39;:::i;:::-;17819:71;17883:6;17878:3;17819:71;:::i;:::-;17812:78;;17899:65;17957:6;17952:3;17945:4;17938:5;17934:16;17899:65;:::i;:::-;17989:29;18011:6;17989:29;:::i;:::-;17984:3;17980:39;17973:46;;17740:285;17648:377;;;;:::o;18031:313::-;18144:4;18182:2;18171:9;18167:18;18159:26;;18231:9;18225:4;18221:20;18217:1;18206:9;18202:17;18195:47;18259:78;18332:4;18323:6;18259:78;:::i;:::-;18251:86;;18031:313;;;;:::o

e597f9908045b5a7c4da9ff81dea65a4c1debb17ae611ec730c5b447ee1823ac