Contract 0xc05b0003a25d31280dda7030e3699f8713cb48a0

/**
 *Submitted for verification at snowtrace.io on 2022-10-11
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

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


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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


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

pragma solidity ^0.8.0;




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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// File: contracts/CrowdSale.sol


pragma solidity ^0.8.0;





contract Crowdsale is Context, ReentrancyGuard {
    using SafeERC20 for IERC20;
    
    // The token being sold
    IERC20 private _token;
    IERC20 public USDT;

    // Address where funds are collected
    address payable private _wallet;
    address payable public _manager;

    uint256 public minBuy       = 150   ether;
    uint256 public maxBuy       = 5000   ether;
    uint256 public sale_price   = 0.043 ether;

    // Amount of wei raised
    uint256 public _weiRaised;
    uint256 public _tokenPurchased;
    bool public success;
    bool public finalized;
    bool public _buyable;
    
    event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
    
    mapping (address => uint256) public purchase;
    mapping (address => uint256) public claimed;
    mapping (address => uint256) public msgValue;

    uint256 current = block.timestamp * 1 seconds;

    uint256 public immutable buyTime;           //  60 days
    uint256 public immutable limitationtime ;   // 180 days
    uint256 public immutable claimeTime;        // 150 days
    
    constructor (uint256 buyTime_, uint256 lockTime, uint256 claimTime_, address payable manager_, 
        IERC20 token_, address payable wallet_) {
        require(address(token_) != address(0), "Crowdsale: token is the zero address");

        _manager = manager_;
        _token = token_;
        _wallet = wallet_;

        buyTime = block.timestamp + buyTime_ * 1 seconds;
        limitationtime = block.timestamp + (buyTime_ + lockTime) * 1 seconds;
        claimeTime = block.timestamp + (buyTime_ + lockTime + claimTime_) * 1 seconds;

        USDT = IERC20(0xc7198437980c041c805A1EDcbA50c1Ce5db95118);   // USDT address on Avalanche C chain
    }
    
    /**
     * @dev fallback function ***DO NOT OVERRIDE***
     * Note that other contracts will transfer funds with a base gas stipend
     * of 2300, which is not enough to call buyTokens. Consider calling
     * buyTokens directly when purchasing tokens from a contract.
     */

    receive () external payable {
    }

    /**
     * @return the token being sold.
     */
    function token() public view returns (IERC20) {
        return _token;
    }

    /**
     * @return the address where funds are collected.
     */
    function wallet() public view returns (address payable) {
        return _wallet;
    }

    function getPrice() public view returns(uint256){
        return (10**18) / sale_price;
    }

    /**
     * @return the amount of wei raised.
     */
    function weiRaised() public view returns (uint256) {
        return _weiRaised;
    }

    function buyable()public returns(bool) { 
        if(buyTime > block.timestamp){
            _buyable = true;
        }
        return _buyable;
    }

    function buyTokens(uint256 amount) public nonReentrant {
        require(buyTime > block.timestamp, "Buy Time expired");
        require(amount >= minBuy && amount <= maxBuy,"Wrong amount range.");

        uint256 one = 1 ether;
        uint256 tokens =  (one * amount) / sale_price;
        require(_token.balanceOf(address(this)) >= tokens, "buy amount exceeds not enough Tokens remaining");

        USDT.safeTransferFrom(_msgSender(), address(this), amount);

        _tokenPurchased = _tokenPurchased + tokens;
        _weiRaised = _weiRaised + amount;
        
        msgValue[_msgSender()] = msgValue[_msgSender()] + amount;
        purchase[_msgSender()] = purchase[_msgSender()] + tokens;
    }

    function pendingTokens(address account) public view returns (uint256) {
        uint value;
        if (block.timestamp < limitationtime)
            value = 0;
        else if (block.timestamp >= claimeTime) {
            value = purchase[account] - claimed[account];
        }
        else {
            uint initValue = purchase[account] / 5;
            uint remainValue = purchase[account] - initValue;

            value = initValue;
            value += remainValue * (block.timestamp - limitationtime) / (claimeTime - limitationtime);
            value -= claimed[account];
        }

        return value;
    }

    function claim() public nonReentrant {
        require (block.timestamp > limitationtime);
        require (finalized,"IDO not finalized yet");

        uint256 tokenAmount = pendingTokens(_msgSender());  
        require (tokenAmount > 0, "0 tokens to claim");
        require(_token.balanceOf(address(this)) >= tokenAmount, "claim amount exceeds not enough Tokens remaining");

        _token.safeTransfer(_msgSender(), tokenAmount);

        claimed[_msgSender()] += tokenAmount;
    }
    
    function balance() public view returns(uint){
        return _token.balanceOf(address(this));
    }

    function finalize() public nonReentrant {
        require( buyTime < block.timestamp, "the crowdSale is in progress");
        require(!finalized,"already finalized");
        require(_msgSender() == _manager,"you are not the owner");

         uint256 remainingTokensInTheContract = _token.balanceOf(address(this)) - _tokenPurchased;
        _token.safeTransfer(address(_wallet), remainingTokensInTheContract);

        _forwardFunds(_weiRaised);
        finalized = true;
    }

    /**
     * @dev Determines how ETH is stored/forwarded on purchases.
     */
    function _forwardFunds(uint256 amount) internal {
      USDT.safeTransfer(_wallet, amount);
    }
}
// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


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

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

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


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

pragma solidity ^0.8.0;


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

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

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

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

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

// File: contracts/Manager.sol


pragma solidity ^0.8.0;







interface ILASM {
    function excludeFromDividends(address account) external;
    function excludeFromFees(address account, bool excluded) external;
}

contract Manager is Context, Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    ILASM token;
    address public ico_addr;
    address[] public rounds;
    uint256[] public roundAmount;

    event CreateTokenSale(uint256 locktime, uint256 amount, uint256 noRounds);
    event WithdrawToken(address recipient, uint256 amountToken);

    constructor(address token_) {
        token = ILASM(token_);
    }

    receive() external payable {}

    function noRounds() public view returns (uint256) {
        return rounds.length;
    }

    function setToken(address token_) public onlyOwner {
        token = ILASM(token_);
    }

    function getToken() public view returns (address) {
        return address(token);
    }

    function transfer(address recipient, uint256 amount)
        public
        payable
        virtual
        onlyOwner
        returns (bool) {
        require(amount <= IERC20(address(token)).balanceOf(address(this)), "not enough amount");
        IERC20(address(token)).safeTransfer(recipient, amount);
        return true;
    }

    function create_TokenSale(
        uint256 buyTime,
        uint256 lockTime,
        uint256 claimTime,
        uint256 amount
    ) public onlyOwner {
        require(getToken() != address(0), "set Token for Sale");

        if (rounds.length > 0) {
            bool status = isSaleFinalized();
            require(status == true, "Sale in progress");
        }

        require(amount <= IERC20(address(token)).balanceOf(address(this)), "not enough amount");

        Crowdsale ico;
        ico = new Crowdsale(
            buyTime,
            lockTime,
            claimTime,
            payable(owner()),
            IERC20(address(token)),
            payable(owner())
        );
        ico_addr = address(ico);

        token.excludeFromDividends(ico_addr);
        token.excludeFromFees(ico_addr, true);

        require(transfer(ico_addr, amount));

        rounds.push(ico_addr);
        roundAmount.push(amount);

        emit CreateTokenSale(lockTime, amount, rounds.length);
    }

    function totalRoundSaleInfo() public view returns (uint256, uint256, uint256) {
        uint256 length = rounds.length;
        uint256 totalAmountToken;
        uint256 totalAmountPurchased;
        uint256 totalAmountFunds;
        for (uint8 i=0; i<length; i++) {
            (uint256 amountToken, uint256 amountPurchased, uint256 amountFunds) = roundSaleInfo(i);
            totalAmountToken += amountToken;
            totalAmountPurchased += amountPurchased;
            totalAmountFunds += amountFunds;
        }

        return (totalAmountToken, totalAmountPurchased, totalAmountFunds);
    }

    function roundSaleInfo(uint8 index) public view returns (uint256, uint256, uint256) {
        require(index < rounds.length, "Wrong Round Index.");
        uint256 amountToken;
        uint256 amountPurchased;
        uint256 amountFunds;

        amountToken += roundAmount[index];

        address sale_addr = rounds[index];
        Crowdsale sale = Crowdsale(payable(sale_addr));
        amountPurchased += sale._tokenPurchased();
        amountFunds += sale._weiRaised();

        return (amountToken, amountPurchased, amountFunds);
    }

    function isSaleFinalized() public view returns (bool) {
        require(rounds.length > 0, "No round");

        address sale_addr = rounds[rounds.length - 1];
        Crowdsale sale = Crowdsale(payable(sale_addr));

        return sale.finalized();
    }

    function withdrawToken() public onlyOwner {
        uint256 remainingTokensInTheContract = IERC20(address(token)).balanceOf(address(this));
        IERC20(address(token)).safeTransfer(msg.sender, remainingTokensInTheContract);

        emit WithdrawToken(msg.sender, remainingTokensInTheContract);
    }
}

[{"inputs":[{"internalType":"address","name":"token_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"locktime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"noRounds","type":"uint256"}],"name":"CreateTokenSale","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountToken","type":"uint256"}],"name":"WithdrawToken","type":"event"},{"inputs":[{"internalType":"uint256","name":"buyTime","type":"uint256"},{"internalType":"uint256","name":"lockTime","type":"uint256"},{"internalType":"uint256","name":"claimTime","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"create_TokenSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ico_addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isSaleFinalized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"noRounds","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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"roundAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"index","type":"uint8"}],"name":"roundSaleInfo","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rounds","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"}],"name":"setToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalRoundSaleInfo","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000009c0c0e21a8a4787e3304f93767695101217de113

-----Decoded View---------------
Arg [0] : token_ (address): 0x9c0c0e21a8a4787e3304f93767695101217de113

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000009c0c0e21a8a4787e3304f93767695101217de113

46886:3918:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47455:91;;;;;;;;;;-1:-1:-1;47455:91:0;;;;;:::i;:::-;;:::i;:::-;;47554:90;;;;;;;;;;-1:-1:-1;47630:5:0;;-1:-1:-1;;;;;47630:5:0;47554:90;;;-1:-1:-1;;;;;547:32:1;;;529:51;;517:2;502:18;47554:90:0;;;;;;;;47358:89;;;;;;;;;;-1:-1:-1;47426:6:0;:13;47358:89;;;737:25:1;;;725:2;710:18;47358:89:0;591:177:1;47060:28:0;;;;;;;;;;-1:-1:-1;47060:28:0;;;;;:::i;:::-;;:::i;45836:103::-;;;;;;;;;;;;;:::i;49659:556::-;;;;;;;;;;-1:-1:-1;49659:556:0;;;;;:::i;:::-;;:::i;:::-;;;;1434:25:1;;;1490:2;1475:18;;1468:34;;;;1518:18;;;1511:34;1422:2;1407:18;49659:556:0;1232:319:1;50223:262:0;;;;;;;;;;;;;:::i;:::-;;;1721:14:1;;1714:22;1696:41;;1684:2;1669:18;50223:262:0;1556:187:1;47030:23:0;;;;;;;;;;-1:-1:-1;47030:23:0;;;;;:::i;:::-;;:::i;45188:87::-;;;;;;;;;;-1:-1:-1;45234:7:0;45261:6;-1:-1:-1;;;;;45261:6:0;45188:87;;47652:339;;;;;;:::i;:::-;;:::i;47999:1030::-;;;;;;;;;;-1:-1:-1;47999:1030:0;;;;;:::i;:::-;;:::i;47000:23::-;;;;;;;;;;-1:-1:-1;47000:23:0;;;;-1:-1:-1;;;;;47000:23:0;;;50493:308;;;;;;;;;;;;;:::i;49037:614::-;;;;;;;;;;;;;:::i;46094:201::-;;;;;;;;;;-1:-1:-1;46094:201:0;;;;;:::i;:::-;;:::i;47455:91::-;45074:13;:11;:13::i;:::-;47517:5:::1;:21:::0;;-1:-1:-1;;;;;;47517:21:0::1;-1:-1:-1::0;;;;;47517:21:0;;;::::1;::::0;;;::::1;::::0;;47455:91::o;47060:28::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47060:28:0;:::o;45836:103::-;45074:13;:11;:13::i;:::-;45901:30:::1;45928:1;45901:18;:30::i;:::-;45836:103::o:0;49659:556::-;49716:7;49725;49734;49770:6;:13;;;;49762:5;:21;;;49754:52;;;;-1:-1:-1;;;49754:52:0;;2599:2:1;49754:52:0;;;2581:21:1;2638:2;2618:18;;;2611:30;-1:-1:-1;;;2657:18:1;;;2650:48;2715:18;;49754:52:0;;;;;;;;;49817:19;49847:23;49881:19;49928:11;49940:5;49928:18;;;;;;;;;;:::i;:::-;;;;;;;;;49913:33;;;;;:::i;:::-;;;49959:17;49979:6;49986:5;49979:13;;;;;;;;;;:::i;:::-;;;;;;;;;;;;50079:22;;;-1:-1:-1;;;50079:22:0;;;;-1:-1:-1;;;;;49979:13:0;;;;-1:-1:-1;49979:13:0;;;;50079:20;;:22;;;;;49979:13;50079:22;;;;;;49979:13;50079:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50060:41;;;;:::i;:::-;;;50127:4;-1:-1:-1;;;;;50127:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50112:32;;;;:::i;:::-;50165:11;;50178:15;;-1:-1:-1;50165:11:0;;-1:-1:-1;49659:556:0;;-1:-1:-1;;;;;49659:556:0:o;50223:262::-;50296:6;:13;50271:4;;50288:38;;;;-1:-1:-1;;;50288:38:0;;3532:2:1;50288:38:0;;;3514:21:1;3571:1;3551:18;;;3544:29;-1:-1:-1;;;3589:18:1;;;3582:38;3637:18;;50288:38:0;3330:331:1;50288:38:0;50359:6;50366:13;;50339:17;;50359:6;50366:17;;50382:1;;50366:17;:::i;:::-;50359:25;;;;;;;;:::i;:::-;;;;;;;;;;;;50461:16;;;-1:-1:-1;;;50461:16:0;;;;-1:-1:-1;;;;;50359:25:0;;;;-1:-1:-1;50359:25:0;;;;50461:14;;:16;;;;;50359:25;50461:16;;;;;;50359:25;50461:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50454:23;;;;50223:262;:::o;47030:23::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;47030:23:0;;-1:-1:-1;47030:23:0;:::o;47652:339::-;47792:4;45074:13;:11;:13::i;:::-;47842:5:::1;::::0;47827:47:::1;::::0;-1:-1:-1;;;47827:47:0;;47868:4:::1;47827:47;::::0;::::1;529:51:1::0;-1:-1:-1;;;;;47842:5:0;;::::1;::::0;47827:32:::1;::::0;502:18:1;;47827:47:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47817:6;:57;;47809:87;;;::::0;-1:-1:-1;;;47809:87:0;;4280:2:1;47809:87:0::1;::::0;::::1;4262:21:1::0;4319:2;4299:18;;;4292:30;-1:-1:-1;;;4338:18:1;;;4331:47;4395:18;;47809:87:0::1;4078:341:1::0;47809:87:0::1;47922:5;::::0;47907:54:::1;::::0;-1:-1:-1;;;;;47922:5:0::1;47943:9:::0;47954:6;47907:35:::1;:54::i;:::-;-1:-1:-1::0;47979:4:0::1;47652:339:::0;;;;:::o;47999:1030::-;45074:13;:11;:13::i;:::-;48196:1:::1;48174:10;47630:5:::0;;-1:-1:-1;;;;;47630:5:0;;47554:90;48174:10:::1;-1:-1:-1::0;;;;;48174:24:0::1;;;48166:55;;;::::0;-1:-1:-1;;;48166:55:0;;4626:2:1;48166:55:0::1;::::0;::::1;4608:21:1::0;4665:2;4645:18;;;4638:30;-1:-1:-1;;;4684:18:1;;;4677:48;4742:18;;48166:55:0::1;4424:342:1::0;48166:55:0::1;48238:6;:13:::0;:17;48234:139:::1;;48272:11;48286:17;:15;:17::i;:::-;48272:31:::0;-1:-1:-1;48336:4:0::1;48326:14:::0;::::1;;;48318:43;;;::::0;-1:-1:-1;;;48318:43:0;;4973:2:1;48318:43:0::1;::::0;::::1;4955:21:1::0;5012:2;4992:18;;;4985:30;-1:-1:-1;;;5031:18:1;;;5024:46;5087:18;;48318:43:0::1;4771:340:1::0;48318:43:0::1;48257:116;48234:139;48418:5;::::0;48403:47:::1;::::0;-1:-1:-1;;;48403:47:0;;48444:4:::1;48403:47;::::0;::::1;529:51:1::0;-1:-1:-1;;;;;48418:5:0;;::::1;::::0;48403:32:::1;::::0;502:18:1;;48403:47:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48393:6;:57;;48385:87;;;::::0;-1:-1:-1;;;48385:87:0;;4280:2:1;48385:87:0::1;::::0;::::1;4262:21:1::0;4319:2;4299:18;;;4292:30;-1:-1:-1;;;4338:18:1;;;4331:47;4395:18;;48385:87:0::1;4078:341:1::0;48385:87:0::1;48485:13;48543:7;48565:8;48588:9;48620:7;45234::::0;45261:6;-1:-1:-1;;;;;45261:6:0;;45188:87;48620:7:::1;48658:5;::::0;-1:-1:-1;;;;;48658:5:0::1;48688:7;45234::::0;45261:6;-1:-1:-1;;;;;45261:6:0;;45188:87;48688:7:::1;48515:192;;;;;:::i;:::-;5449:25:1::0;;;5505:2;5490:18;;5483:34;;;;5548:2;5533:18;;5526:34;;;;-1:-1:-1;;;;;5634:15:1;;;5629:2;5614:18;;5607:43;5687:15;;;5681:3;5666:19;;5659:44;5740:15;5587:3;5719:19;;5712:44;5436:3;5421:19;48515:192:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;48718:8:0::1;:23:::0;;-1:-1:-1;;;;;;48718:23:0::1;-1:-1:-1::0;;;;;48718:23:0;;::::1;::::0;;::::1;::::0;;;48754:5:::1;::::0;:36:::1;::::0;-1:-1:-1;;;48754:36:0;;::::1;::::0;::::1;529:51:1::0;;;;48718:23:0;;-1:-1:-1;48754:5:0;::::1;::::0;:26:::1;::::0;502:18:1;;48754:36:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;48801:5:0::1;::::0;48823:8:::1;::::0;48801:37:::1;::::0;-1:-1:-1;;;48801:37:0;;-1:-1:-1;;;;;48823:8:0;;::::1;48801:37;::::0;::::1;5935:51:1::0;48801:5:0;6002:18:1;;;5995:50;48801:5:0;::::1;::::0;-1:-1:-1;48801:21:0::1;::::0;-1:-1:-1;5908:18:1;;48801:37:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;48868:8:0::1;::::0;48859:26:::1;::::0;-1:-1:-1;;;;;;48868:8:0::1;::::0;-1:-1:-1;48878:6:0;48859:8:::1;:26::i;:::-;48851:35;;;::::0;::::1;;48911:8;::::0;48899:6:::1;:21:::0;;48911:8;48899:21;;::::1;::::0;;;;;::::1;::::0;;-1:-1:-1;;;;;;48899:21:0::1;-1:-1:-1::0;;;;;48911:8:0;;::::1;48899:21:::0;;;::::1;::::0;;;48931:11:::1;:24:::0;;;;::::1;::::0;;-1:-1:-1;48931:24:0;;;;::::1;::::0;;;49007:13;48973:48:::1;::::0;;1434:25:1;;;1490:2;1475:18;;1468:34;;;1518:18;;;1511:34;;;;48973:48:0::1;::::0;1422:2:1;1407:18;48973:48:0::1;;;;;;;48155:874;47999:1030:::0;;;;:::o;50493:308::-;45074:13;:11;:13::i;:::-;50600:5:::1;::::0;50585:47:::1;::::0;-1:-1:-1;;;50585:47:0;;50626:4:::1;50585:47;::::0;::::1;529:51:1::0;50546:36:0::1;::::0;-1:-1:-1;;;;;50600:5:0::1;::::0;50585:32:::1;::::0;502:18:1;;50585:47:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50658:5;::::0;50546:86;;-1:-1:-1;50643:77:0::1;::::0;-1:-1:-1;;;;;50658:5:0::1;50679:10;50546:86:::0;50643:35:::1;:77::i;:::-;50738:55;::::0;;50752:10:::1;6230:51:1::0;;6312:2;6297:18;;6290:34;;;50738:55:0::1;::::0;6203:18:1;50738:55:0::1;;;;;;;50535:266;50493:308::o:0;49037:614::-;49143:6;:13;49088:7;;;;;;;;;;49276:290;49294:6;49292:1;:8;;;49276:290;;;49323:19;49344:23;49369:19;49392:16;49406:1;49392:13;:16::i;:::-;49322:86;;-1:-1:-1;49322:86:0;-1:-1:-1;49322:86:0;-1:-1:-1;49423:31:0;49322:86;49423:31;;:::i;:::-;;-1:-1:-1;49469:39:0;49493:15;49469:39;;:::i;:::-;;-1:-1:-1;49523:31:0;49543:11;49523:31;;:::i;:::-;;;49307:259;;;49302:3;;;;;:::i;:::-;;;;49276:290;;;-1:-1:-1;49586:16:0;;49604:20;;-1:-1:-1;49626:16:0;;-1:-1:-1;49037:614:0;-1:-1:-1;;49037:614:0:o;46094:201::-;45074:13;:11;:13::i;:::-;-1:-1:-1;;;;;46183:22:0;::::1;46175:73;;;::::0;-1:-1:-1;;;46175:73:0;;6717:2:1;46175:73:0::1;::::0;::::1;6699:21:1::0;6756:2;6736:18;;;6729:30;6795:34;6775:18;;;6768:62;-1:-1:-1;;;6846:18:1;;;6839:36;6892:19;;46175:73:0::1;6515:402:1::0;46175:73:0::1;46259:28;46278:8;46259:18;:28::i;:::-;46094:201:::0;:::o;45353:132::-;45234:7;45261:6;-1:-1:-1;;;;;45261:6:0;22589:10;45417:23;45409:68;;;;-1:-1:-1;;;45409:68:0;;7124:2:1;45409:68:0;;;7106:21:1;;;7143:18;;;7136:30;7202:34;7182:18;;;7175:62;7254:18;;45409:68:0;6922:356:1;46455:191:0;46529:16;46548:6;;-1:-1:-1;;;;;46565:17:0;;;-1:-1:-1;;;;;;46565:17:0;;;;;;46598:40;;46548:6;;;;;;;46598:40;;46529:16;46598:40;46518:128;46455:191;:::o;18040:211::-;18184:58;;;-1:-1:-1;;;;;6248:32:1;;18184:58:0;;;6230:51:1;6297:18;;;;6290:34;;;18184:58:0;;;;;;;;;;6203:18:1;;;;18184:58:0;;;;;;;;-1:-1:-1;;;;;18184:58:0;-1:-1:-1;;;18184:58:0;;;18157:86;;18177:5;;18157:19;:86::i;:::-;18040:211;;;:::o;21107:716::-;21531:23;21557:69;21585:4;21557:69;;;;;;;;;;;;;;;;;21565:5;-1:-1:-1;;;;;21557:27:0;;;:69;;;;;:::i;:::-;21641:17;;21531:95;;-1:-1:-1;21641:21:0;21637:179;;21738:10;21727:30;;;;;;;;;;;;:::i;:::-;21719:85;;;;-1:-1:-1;;;21719:85:0;;7485:2:1;21719:85:0;;;7467:21:1;7524:2;7504:18;;;7497:30;7563:34;7543:18;;;7536:62;-1:-1:-1;;;7614:18:1;;;7607:40;7664:19;;21719:85:0;7283:406:1;6772:229:0;6909:12;6941:52;6963:6;6971:4;6977:1;6980:12;6941:21;:52::i;:::-;6934:59;;6772:229;;;;;;:::o;7892:510::-;8062:12;8120:5;8095:21;:30;;8087:81;;;;-1:-1:-1;;;8087:81:0;;7896:2:1;8087:81:0;;;7878:21:1;7935:2;7915:18;;;7908:30;7974:34;7954:18;;;7947:62;-1:-1:-1;;;8025:18:1;;;8018:36;8071:19;;8087:81:0;7694:402:1;8087:81:0;-1:-1:-1;;;;;4322:19:0;;;8179:60;;;;-1:-1:-1;;;8179:60:0;;8303:2:1;8179:60:0;;;8285:21:1;8342:2;8322:18;;;8315:30;8381:31;8361:18;;;8354:59;8430:18;;8179:60:0;8101:353:1;8179:60:0;8253:12;8267:23;8294:6;-1:-1:-1;;;;;8294:11:0;8313:5;8320:4;8294:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8252:73;;;;8343:51;8360:7;8369:10;8381:12;8343:16;:51::i;:::-;8336:58;7892:510;-1:-1:-1;;;;;;;7892:510:0:o;10578:762::-;10728:12;10757:7;10753:580;;;-1:-1:-1;10788:10:0;10781:17;;10753:580;10902:17;;:21;10898:424;;11150:10;11144:17;11211:15;11198:10;11194:2;11190:19;11183:44;10898:424;11293:12;11286:20;;-1:-1:-1;;;11286:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;773:180::-;832:6;885:2;873:9;864:7;860:23;856:32;853:52;;;901:1;898;891:12;853:52;-1:-1:-1;924:23:1;;773:180;-1:-1:-1;773:180:1:o;958:269::-;1015:6;1068:2;1056:9;1047:7;1043:23;1039:32;1036:52;;;1084:1;1081;1074:12;1036:52;1123:9;1110:23;1173:4;1166:5;1162:16;1155:5;1152:27;1142:55;;1193:1;1190;1183:12;1748:254;1816:6;1824;1877:2;1865:9;1856:7;1852:23;1848:32;1845:52;;;1893:1;1890;1883:12;1845:52;1916:29;1935:9;1916:29;:::i;:::-;1906:39;1992:2;1977:18;;;;1964:32;;-1:-1:-1;;;1748:254:1:o;2007:385::-;2093:6;2101;2109;2117;2170:3;2158:9;2149:7;2145:23;2141:33;2138:53;;;2187:1;2184;2177:12;2138:53;-1:-1:-1;;2210:23:1;;;2280:2;2265:18;;2252:32;;-1:-1:-1;2331:2:1;2316:18;;2303:32;;2382:2;2367:18;2354:32;;-1:-1:-1;2007:385:1;-1:-1:-1;2007:385:1:o;2744:127::-;2805:10;2800:3;2796:20;2793:1;2786:31;2836:4;2833:1;2826:15;2860:4;2857:1;2850:15;2876:127;2937:10;2932:3;2928:20;2925:1;2918:31;2968:4;2965:1;2958:15;2992:4;2989:1;2982:15;3008:128;3048:3;3079:1;3075:6;3072:1;3069:13;3066:39;;;3085:18;;:::i;:::-;-1:-1:-1;3121:9:1;;3008:128::o;3141:184::-;3211:6;3264:2;3252:9;3243:7;3239:23;3235:32;3232:52;;;3280:1;3277;3270:12;3232:52;-1:-1:-1;3303:16:1;;3141:184;-1:-1:-1;3141:184:1:o;3666:125::-;3706:4;3734:1;3731;3728:8;3725:34;;;3739:18;;:::i;:::-;-1:-1:-1;3776:9:1;;3666:125::o;3796:277::-;3863:6;3916:2;3904:9;3895:7;3891:23;3887:32;3884:52;;;3932:1;3929;3922:12;3884:52;3964:9;3958:16;4017:5;4010:13;4003:21;3996:5;3993:32;3983:60;;4039:1;4036;4029:12;6335:175;6372:3;6416:4;6409:5;6405:16;6445:4;6436:7;6433:17;6430:43;;;6453:18;;:::i;:::-;6502:1;6489:15;;6335:175;-1:-1:-1;;6335:175:1:o;8459:258::-;8531:1;8541:113;8555:6;8552:1;8549:13;8541:113;;;8631:11;;;8625:18;8612:11;;;8605:39;8577:2;8570:10;8541:113;;;8672:6;8669:1;8666:13;8663:48;;;8707:1;8698:6;8693:3;8689:16;8682:27;8663:48;;8459:258;;;:::o;8722:274::-;8851:3;8889:6;8883:13;8905:53;8951:6;8946:3;8939:4;8931:6;8927:17;8905:53;:::i;:::-;8974:16;;;;;8722:274;-1:-1:-1;;8722:274:1:o;9001:383::-;9150:2;9139:9;9132:21;9113:4;9182:6;9176:13;9225:6;9220:2;9209:9;9205:18;9198:34;9241:66;9300:6;9295:2;9284:9;9280:18;9275:2;9267:6;9263:15;9241:66;:::i;:::-;9368:2;9347:15;-1:-1:-1;;9343:29:1;9328:45;;;;9375:2;9324:54;;9001:383;-1:-1:-1;;9001:383:1:o

ipfs://f9bb825fc07174ba09eac268585038be1ad95f0ff2f0a9eb7a90cbdee47cf8fb