Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract RainVestingV2 is Ownable *
•    - function addBeneficiaries(address[] m ...
•    - function addBeneficiary(address _bene ...
•    - function claimTokens()
•    - function userReleasableAmount(address ...
•    - function releasableAmount(address _ac ...
•    - function totalAmounts()
•    - function release(address _beneficiary ...
•    - function getBeneficiariesLength()
•    - function withdraw(IERC20 _token)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-03-05
*/

pragma solidity 0.8.10;


// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.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");
        }
    }
}

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
 * @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;
    }
}

// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
/**
 * @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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

contract RainVestingV2 is Ownable {
    using SafeERC20 for IERC20;

    event Released(address beneficiary, uint256 amount);

    IERC20 public immutable token;
    uint256 public immutable lockupTime;
    uint256 public immutable percentUpfront;
    uint256 public immutable start;
    uint256 public immutable duration;

    mapping(address => uint256) public tokenAmounts;
    mapping(address => uint256) public lastReleaseDate;
    mapping(address => uint256) public releasedAmount;

    uint256 private released;
    uint256 private constant BP = 1000000;

    address[] public beneficiaries;

    constructor(
        IERC20 _token,
        uint256 _start,
        uint256 _lockupTime,
        uint256 _percentUpfront,
        uint256 _duration
    ) {
        require(
            _lockupTime <= _duration,
            "Cliff has to be lower or equal to duration"
        );
        token = _token;
        duration = _duration;
        lockupTime = _start + _lockupTime;
        percentUpfront = _percentUpfront;
        start = _start;
    }

    function addBeneficiaries(address[] memory _beneficiaries, uint256[] memory _tokenAmounts) public onlyOwner {
        require(_beneficiaries.length == _tokenAmounts.length, "Invalid params");

        for (uint i = 0; i <_beneficiaries.length; i++) {
            addBeneficiary(_beneficiaries[i], _tokenAmounts[i]);
        }
    }
    
    function addBeneficiary(address _beneficiary, uint256 _tokenAmount) private {
        require(_beneficiary != address(0), "The beneficiary's address cannot be 0");
        require(_tokenAmount > 0, "Amount has to be greater than 0");

        if (tokenAmounts[_beneficiary] == 0) {
            beneficiaries.push(_beneficiary);
        }

        lastReleaseDate[_beneficiary] = lockupTime;
        tokenAmounts[_beneficiary] += _tokenAmount;
    }

    function claimTokens() public {
        require(
            releasedAmount[msg.sender] < tokenAmounts[msg.sender],
            "User already released all available tokens"
        );

        uint256 unreleased = releasableAmount(msg.sender) - releasedAmount[msg.sender];
        
        if (unreleased > 0) {
            released += unreleased;
            release(msg.sender, unreleased);
            lastReleaseDate[msg.sender] = block.timestamp;
        }
    }

    function userReleasableAmount(address _account) public view returns (uint256) {
        return releasableAmount(_account);
    }

    function releasableAmount(address _account) private view returns (uint256) {
        // Return 0 if time is before lockupTime
        if (block.timestamp < lastReleaseDate[_account]) return 0; 

        // Continue if time is after lockupTime
        uint256 upfrontPayment;
        if (percentUpfront > 0) { 
            // Calculate upfront payment
            upfrontPayment = (tokenAmounts[_account] * percentUpfront) / BP;
        }

        uint256 timePassed = block.timestamp - lockupTime; // Time passed after lockupTime
        
        // Is timePassed after lockupTime and before vesting end?
        if (timePassed <= duration - (lockupTime - start)) {
            // UpfrontPayment + (TotalAfterUpfront * TimePassed / (TimeAfterUpfrontEnd))
            return upfrontPayment + (tokenAmounts[_account] - upfrontPayment) * timePassed / (duration - (lockupTime - start));
        } else { 
            // Time is after vesting end, return all the tokens
            return tokenAmounts[_account]; 
        }
    }

    function totalAmounts() public view returns (uint256 sum) {
        for (uint256 i = 0; i < beneficiaries.length; i++) {
            sum += tokenAmounts[beneficiaries[i]];
        }
    }

    function release(address _beneficiary, uint256 _amount) private {
        token.safeTransfer(_beneficiary, _amount);
        releasedAmount[_beneficiary] += _amount;
        emit Released(_beneficiary, _amount);
    }

    function getBeneficiariesLength() external view returns (uint256){
        return beneficiaries.length;
    }

    function withdraw(IERC20 _token) external onlyOwner {
        if (_token == IERC20(address(0))) {
            // allow to rescue ether
            payable(owner()).transfer(address(this).balance);
        } else {
            uint256 withdrawAmount = _token.balanceOf(address(this));
            if (withdrawAmount > 0) {
                _token.safeTransfer(address(msg.sender), withdrawAmount);
            }
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"_start","type":"uint256"},{"internalType":"uint256","name":"_lockupTime","type":"uint256"},{"internalType":"uint256","name":"_percentUpfront","type":"uint256"},{"internalType":"uint256","name":"_duration","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Released","type":"event"},{"inputs":[{"internalType":"address[]","name":"_beneficiaries","type":"address[]"},{"internalType":"uint256[]","name":"_tokenAmounts","type":"uint256[]"}],"name":"addBeneficiaries","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"beneficiaries","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBeneficiariesLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastReleaseDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockupTime","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":"percentUpfront","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"releasedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"start","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokenAmounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAmounts","outputs":[{"internalType":"uint256","name":"sum","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"userReleasableAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

61012060405234801561001157600080fd5b5060405161143f38038061143f8339810160408190526100309161011e565b610039336100ce565b808311156100a05760405162461bcd60e51b815260206004820152602a60248201527f436c6966662068617320746f206265206c6f776572206f7220657175616c20746044820152693790323ab930ba34b7b760b11b606482015260840160405180910390fd5b6001600160a01b0385166080526101008190526100bd8385610173565b60a0525060c0525060e05250610199565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b600080600080600060a0868803121561013657600080fd5b85516001600160a01b038116811461014d57600080fd5b602087015160408801516060890151608090990151929a91995097965090945092505050565b6000821982111561019457634e487b7160e01b600052601160045260246000fd5b500190565b60805160a05160c05160e0516101005161121561022a600039600081816101620152818161083e01526108b801526000818161024e015281816107f3015261086d01526000818161027501528181610746015261078e01526000818161013b015281816107c7015281816108140152818161088e0152610bc90152600081816102d5015261095301526112156000f3fe608060405234801561001057600080fd5b50600436106101165760003560e01c80638da5cb5b116100a2578063ddbeb86011610071578063ddbeb86014610270578063efeb5e5814610297578063f119b250146102aa578063f2fde38b146102bd578063fc0c546a146102d057600080fd5b80638da5cb5b146101f1578063a0e2e5f614610216578063a961065514610236578063be9a65551461024957600080fd5b806348c54b9d116100e957806348c54b9d146101a457806351cff8d9146101ae5780635e26184a146101c1578063715018a6146101c957806376272bdc146101d157600080fd5b80630c6ffc291461011b5780630d05d69d146101365780630fb5a6b41461015d5780631cf1bb7214610184575b600080fd5b6101236102f7565b6040519081526020015b60405180910390f35b6101237f000000000000000000000000000000000000000000000000000000000000000081565b6101237f000000000000000000000000000000000000000000000000000000000000000081565b610123610192366004610e6b565b60036020526000908152604090205481565b6101ac610363565b005b6101ac6101bc366004610e6b565b610449565b600554610123565b6101ac610546565b6101236101df366004610e6b565b60026020526000908152604090205481565b6000546001600160a01b03165b6040516001600160a01b03909116815260200161012d565b610123610224366004610e6b565b60016020526000908152604090205481565b6101ac610244366004610f5e565b61057c565b6101237f000000000000000000000000000000000000000000000000000000000000000081565b6101237f000000000000000000000000000000000000000000000000000000000000000081565b6101fe6102a5366004611020565b610647565b6101236102b8366004610e6b565b610671565b6101ac6102cb366004610e6b565b610682565b6101fe7f000000000000000000000000000000000000000000000000000000000000000081565b6000805b60055481101561035f57600160006005838154811061031c5761031c611039565b60009182526020808320909101546001600160a01b0316835282019290925260400190205461034b9083611065565b9150806103578161107d565b9150506102fb565b5090565b33600090815260016020908152604080832054600390925290912054106103e45760405162461bcd60e51b815260206004820152602a60248201527f5573657220616c72656164792072656c656173656420616c6c20617661696c61604482015269626c6520746f6b656e7360b01b60648201526084015b60405180910390fd5b3360008181526003602052604081205490916103ff9061071a565b6104099190611098565b905080156104465780600460008282546104239190611065565b9091555061043390503382610946565b3360009081526002602052604090204290555b50565b6000546001600160a01b031633146104735760405162461bcd60e51b81526004016103db906110af565b6001600160a01b0381166104bf57600080546040516001600160a01b03909116914780156108fc02929091818181858888f193505050501580156104bb573d6000803e3d6000fd5b5050565b6040516370a0823160e01b81523060048201526000906001600160a01b038316906370a0823190602401602060405180830381865afa158015610506573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061052a91906110e4565b905080156104bb576104bb6001600160a01b03831633836109ed565b6000546001600160a01b031633146105705760405162461bcd60e51b81526004016103db906110af565b61057a6000610a3f565b565b6000546001600160a01b031633146105a65760405162461bcd60e51b81526004016103db906110af565b80518251146105e85760405162461bcd60e51b815260206004820152600e60248201526d496e76616c696420706172616d7360901b60448201526064016103db565b60005b82518110156106425761063083828151811061060957610609611039565b602002602001015183838151811061062357610623611039565b6020026020010151610a8f565b8061063a8161107d565b9150506105eb565b505050565b6005818154811061065757600080fd5b6000918252602090912001546001600160a01b0316905081565b600061067c8261071a565b92915050565b6000546001600160a01b031633146106ac5760405162461bcd60e51b81526004016103db906110af565b6001600160a01b0381166107115760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016103db565b61044681610a3f565b6001600160a01b03811660009081526002602052604081205442101561074257506000919050565b60007f0000000000000000000000000000000000000000000000000000000000000000156107c0576001600160a01b038316600090815260016020526040902054620f4240906107b3907f0000000000000000000000000000000000000000000000000000000000000000906110fd565b6107bd919061111c565b90505b60006107ec7f000000000000000000000000000000000000000000000000000000000000000042611098565b90506108387f00000000000000000000000000000000000000000000000000000000000000007f0000000000000000000000000000000000000000000000000000000000000000611098565b610862907f0000000000000000000000000000000000000000000000000000000000000000611098565b8111610928576108b27f00000000000000000000000000000000000000000000000000000000000000007f0000000000000000000000000000000000000000000000000000000000000000611098565b6108dc907f0000000000000000000000000000000000000000000000000000000000000000611098565b6001600160a01b0385166000908152600160205260409020548290610902908590611098565b61090c91906110fd565b610916919061111c565b6109209083611065565b949350505050565b5050506001600160a01b031660009081526001602052604090205490565b61097a6001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001683836109ed565b6001600160a01b038216600090815260036020526040812080548392906109a2908490611065565b9091555050604080516001600160a01b0384168152602081018390527fb21fb52d5749b80f3182f8c6992236b5e5576681880914484d7f4c9b062e619e910160405180910390a15050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b179052610642908490610c0a565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6001600160a01b038216610af35760405162461bcd60e51b815260206004820152602560248201527f5468652062656e6566696369617279277320616464726573732063616e6e6f74604482015264020626520360dc1b60648201526084016103db565b60008111610b435760405162461bcd60e51b815260206004820152601f60248201527f416d6f756e742068617320746f2062652067726561746572207468616e20300060448201526064016103db565b6001600160a01b038216600090815260016020526040902054610bac57600580546001810182556000919091527f036b6384b5eca791c62761152d0c79bb0604c104a5fb6f4eb0703f3154bb3db00180546001600160a01b0319166001600160a01b0384161790555b6001600160a01b03821660009081526002602090815260408083207f00000000000000000000000000000000000000000000000000000000000000009055600190915281208054839290610c01908490611065565b90915550505050565b6000610c5f826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b0316610cdc9092919063ffffffff16565b8051909150156106425780806020019051810190610c7d919061113e565b6106425760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b60648201526084016103db565b6060610ceb8484600085610cf5565b90505b9392505050565b606082471015610d565760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b60648201526084016103db565b843b610da45760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016103db565b600080866001600160a01b03168587604051610dc09190611190565b60006040518083038185875af1925050503d8060008114610dfd576040519150601f19603f3d011682016040523d82523d6000602084013e610e02565b606091505b5091509150610e12828286610e1d565b979650505050505050565b60608315610e2c575081610cee565b825115610e3c5782518084602001fd5b8160405162461bcd60e51b81526004016103db91906111ac565b6001600160a01b038116811461044657600080fd5b600060208284031215610e7d57600080fd5b8135610cee81610e56565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff81118282101715610ec757610ec7610e88565b604052919050565b600067ffffffffffffffff821115610ee957610ee9610e88565b5060051b60200190565b600082601f830112610f0457600080fd5b81356020610f19610f1483610ecf565b610e9e565b82815260059290921b84018101918181019086841115610f3857600080fd5b8286015b84811015610f535780358352918301918301610f3c565b509695505050505050565b60008060408385031215610f7157600080fd5b823567ffffffffffffffff80821115610f8957600080fd5b818501915085601f830112610f9d57600080fd5b81356020610fad610f1483610ecf565b82815260059290921b84018101918181019089841115610fcc57600080fd5b948201945b83861015610ff3578535610fe481610e56565b82529482019490820190610fd1565b9650508601359250508082111561100957600080fd5b5061101685828601610ef3565b9150509250929050565b60006020828403121561103257600080fd5b5035919050565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b600082198211156110785761107861104f565b500190565b60006000198214156110915761109161104f565b5060010190565b6000828210156110aa576110aa61104f565b500390565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b6000602082840312156110f657600080fd5b5051919050565b60008160001904831182151516156111175761111761104f565b500290565b60008261113957634e487b7160e01b600052601260045260246000fd5b500490565b60006020828403121561115057600080fd5b81518015158114610cee57600080fd5b60005b8381101561117b578181015183820152602001611163565b8381111561118a576000848401525b50505050565b600082516111a2818460208701611160565b9190910192915050565b60208152600082518060208401526111cb816040850160208701611160565b601f01601f1916919091016040019291505056fea2646970667358221220c7b5263bb0c484cc82094c2f231d31ea0f76d59576e250d25d852c8afd13d54564736f6c634300080a003300000000000000000000000071fc1f555a39e0b698653ab0b475488ec3c34d570000000000000000000000000000000000000000000000000000000061bfc7800000000000000000000000000000000000000000000000000000000000ed4e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003b53800

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

00000000000000000000000071fc1f555a39e0b698653ab0b475488ec3c34d570000000000000000000000000000000000000000000000000000000061bfc7800000000000000000000000000000000000000000000000000000000000ed4e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003b53800

-----Decoded View---------------
Arg [0] : _token (address): 0x71Fc1F555a39E0B698653AB0b475488EC3c34D57
Arg [1] : _start (uint256): 1639958400
Arg [2] : _lockupTime (uint256): 15552000
Arg [3] : _percentUpfront (uint256): 0
Arg [4] : _duration (uint256): 62208000

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 00000000000000000000000071fc1f555a39e0b698653ab0b475488ec3c34d57
Arg [1] : 0000000000000000000000000000000000000000000000000000000061bfc780
Arg [2] : 0000000000000000000000000000000000000000000000000000000000ed4e00
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000003b53800

18074:4574:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21663:191;;;:::i;:::-;;;160:25:1;;;148:2;133:18;21663:191:0;;;;;;;;18246:35;;;;;18371:33;;;;;18524:49;;;;;;:::i;:::-;;;;;;;;;;;;;;19984:480;;;:::i;:::-;;22210:435;;;;;;:::i;:::-;;:::i;22091:111::-;22174:13;:20;22091:111;;17257:103;;;:::i;18467:50::-;;;;;;:::i;:::-;;;;;;;;;;;;;;16606:87;16652:7;16679:6;-1:-1:-1;;;;;16679:6:0;16606:87;;;-1:-1:-1;;;;;1013:32:1;;;995:51;;983:2;968:18;16606:87:0;849:203:1;18413:47:0;;;;;;:::i;:::-;;;;;;;;;;;;;;19169:337;;;;;;:::i;:::-;;:::i;18334:30::-;;;;;18288:39;;;;;18659:30;;;;;;:::i;:::-;;:::i;20472:130::-;;;;;;:::i;:::-;;:::i;17515:201::-;;;;;;:::i;:::-;;:::i;18210:29::-;;;;;21663:191;21708:11;;21732:115;21756:13;:20;21752:24;;21732:115;;;21805:12;:30;21818:13;21832:1;21818:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;21818:16:0;21805:30;;;;;;;;;;;;;21798:37;;;;:::i;:::-;;-1:-1:-1;21778:3:0;;;;:::i;:::-;;;;21732:115;;;;21663:191;:::o;19984:480::-;20089:10;20076:24;;;;:12;:24;;;;;;;;;20047:14;:26;;;;;;;:53;20025:145;;;;-1:-1:-1;;;20025:145:0;;4689:2:1;20025:145:0;;;4671:21:1;4728:2;4708:18;;;4701:30;4767:34;4747:18;;;4740:62;-1:-1:-1;;;4818:18:1;;;4811:40;4868:19;;20025:145:0;;;;;;;;;20250:10;20183:18;20235:26;;;:14;:26;;;;;;20183:18;;20204:28;;:16;:28::i;:::-;:57;;;;:::i;:::-;20183:78;-1:-1:-1;20286:14:0;;20282:175;;20329:10;20317:8;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;20354:31:0;;-1:-1:-1;20362:10:0;20374;20354:7;:31::i;:::-;20416:10;20400:27;;;;:15;:27;;;;;20430:15;20400:45;;20282:175;20014:450;19984:480::o;22210:435::-;16652:7;16679:6;-1:-1:-1;;;;;16679:6:0;15498:10;16826:23;16818:68;;;;-1:-1:-1;;;16818:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;22277:28:0;::::1;22273:365;;16652:7:::0;16679:6;;22360:48:::1;::::0;-1:-1:-1;;;;;16679:6:0;;;;22386:21:::1;22360:48:::0;::::1;;;::::0;22386:21;;22360:48;16652:7;22360:48;22386:21;16679:6;22360:48;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;20014:450:::0;19984:480::o;22273:365::-:1;22466:31;::::0;-1:-1:-1;;;22466:31:0;;22491:4:::1;22466:31;::::0;::::1;995:51:1::0;22441:22:0::1;::::0;-1:-1:-1;;;;;22466:16:0;::::1;::::0;::::1;::::0;968:18:1;;22466:31:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22441:56:::0;-1:-1:-1;22516:18:0;;22512:115:::1;;22555:56;-1:-1:-1::0;;;;;22555:19:0;::::1;22583:10;22596:14:::0;22555:19:::1;:56::i;17257:103::-:0;16652:7;16679:6;-1:-1:-1;;;;;16679:6:0;15498:10;16826:23;16818:68;;;;-1:-1:-1;;;16818:68:0;;;;;;;:::i;:::-;17322:30:::1;17349:1;17322:18;:30::i;:::-;17257:103::o:0;19169:337::-;16652:7;16679:6;-1:-1:-1;;;;;16679:6:0;15498:10;16826:23;16818:68;;;;-1:-1:-1;;;16818:68:0;;;;;;;:::i;:::-;19321:13:::1;:20;19296:14;:21;:45;19288:72;;;::::0;-1:-1:-1;;;19288:72:0;;5780:2:1;19288:72:0::1;::::0;::::1;5762:21:1::0;5819:2;5799:18;;;5792:30;-1:-1:-1;;;5838:18:1;;;5831:44;5892:18;;19288:72:0::1;5578:338:1::0;19288:72:0::1;19378:6;19373:126;19393:14;:21;19390:1;:24;19373:126;;;19436:51;19451:14;19466:1;19451:17;;;;;;;;:::i;:::-;;;;;;;19470:13;19484:1;19470:16;;;;;;;;:::i;:::-;;;;;;;19436:14;:51::i;:::-;19416:3:::0;::::1;::::0;::::1;:::i;:::-;;;;19373:126;;;;19169:337:::0;;:::o;18659:30::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18659:30:0;;-1:-1:-1;18659:30:0;:::o;20472:130::-;20541:7;20568:26;20585:8;20568:16;:26::i;:::-;20561:33;20472:130;-1:-1:-1;;20472:130:0:o;17515:201::-;16652:7;16679:6;-1:-1:-1;;;;;16679:6:0;15498:10;16826:23;16818:68;;;;-1:-1:-1;;;16818:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;17604:22:0;::::1;17596:73;;;::::0;-1:-1:-1;;;17596:73:0;;6123:2:1;17596:73:0::1;::::0;::::1;6105:21:1::0;6162:2;6142:18;;;6135:30;6201:34;6181:18;;;6174:62;-1:-1:-1;;;6252:18:1;;;6245:36;6298:19;;17596:73:0::1;5921:402:1::0;17596:73:0::1;17680:28;17699:8;17680:18;:28::i;20610:1045::-:0;-1:-1:-1;;;;;20768:25:0;;20676:7;20768:25;;;:15;:25;;;;;;20750:15;:43;20746:57;;;-1:-1:-1;20802:1:0;;20610:1045;-1:-1:-1;20610:1045:0:o;20746:57::-;20866:22;20903:14;:18;20899:157;;-1:-1:-1;;;;;20999:22:0;;;;;;:12;:22;;;;;;18643:7;;20999:39;;21024:14;;20999:39;:::i;:::-;20998:46;;;;:::i;:::-;20981:63;;20899:157;21068:18;21089:28;21107:10;21089:15;:28;:::i;:::-;21068:49;-1:-1:-1;21267:18:0;21280:5;21267:10;:18;:::i;:::-;21255:31;;:8;:31;:::i;:::-;21241:10;:45;21237:411;;21487:18;21500:5;21487:10;:18;:::i;:::-;21475:31;;:8;:31;:::i;:::-;-1:-1:-1;;;;;21418:22:0;;;;;;:12;:22;;;;;;21461:10;;21418:39;;21443:14;;21418:39;:::i;:::-;21417:54;;;;:::i;:::-;:90;;;;:::i;:::-;21400:107;;:14;:107;:::i;:::-;21393:114;20610:1045;-1:-1:-1;;;;20610:1045:0:o;21237:411::-;-1:-1:-1;;;;;;;;21613:22:0;;;;;:12;:22;;;;;;;20610:1045::o;21862:221::-;21937:41;-1:-1:-1;;;;;21937:5:0;:18;21956:12;21970:7;21937:18;:41::i;:::-;-1:-1:-1;;;;;21989:28:0;;;;;;:14;:28;;;;;:39;;22021:7;;21989:28;:39;;22021:7;;21989:39;:::i;:::-;;;;-1:-1:-1;;22044:31:0;;;-1:-1:-1;;;;;6915:32:1;;6897:51;;6979:2;6964:18;;6957:34;;;22044:31:0;;6870:18:1;22044:31:0;;;;;;;21862:221;;:::o;11528:211::-;11672:58;;;-1:-1:-1;;;;;6915:32:1;;11672:58:0;;;6897:51:1;6964:18;;;;6957:34;;;11672:58:0;;;;;;;;;;6870:18:1;;;;11672:58:0;;;;;;;;-1:-1:-1;;;;;11672:58:0;-1:-1:-1;;;11672:58:0;;;11645:86;;11665:5;;11645:19;:86::i;17876:191::-;17950:16;17969:6;;-1:-1:-1;;;;;17986:17:0;;;-1:-1:-1;;;;;;17986:17:0;;;;;;18019:40;;17969:6;;;;;;;18019:40;;17950:16;18019:40;17939:128;17876:191;:::o;19518:458::-;-1:-1:-1;;;;;19613:26:0;;19605:76;;;;-1:-1:-1;;;19605:76:0;;7204:2:1;19605:76:0;;;7186:21:1;7243:2;7223:18;;;7216:30;7282:34;7262:18;;;7255:62;-1:-1:-1;;;7333:18:1;;;7326:35;7378:19;;19605:76:0;7002:401:1;19605:76:0;19715:1;19700:12;:16;19692:60;;;;-1:-1:-1;;;19692:60:0;;7610:2:1;19692:60:0;;;7592:21:1;7649:2;7629:18;;;7622:30;7688:33;7668:18;;;7661:61;7739:18;;19692:60:0;7408:355:1;19692:60:0;-1:-1:-1;;;;;19769:26:0;;;;;;:12;:26;;;;;;19765:96;;19817:13;:32;;;;;;;-1:-1:-1;19817:32:0;;;;;;;;-1:-1:-1;;;;;;19817:32:0;-1:-1:-1;;;;;19817:32:0;;;;;19765:96;-1:-1:-1;;;;;19873:29:0;;;;;;:15;:29;;;;;;;;19905:10;19873:42;;19926:12;:26;;;;;:42;;19956:12;;19873:29;19926:42;;19956:12;;19926:42;:::i;:::-;;;;-1:-1:-1;;;;19518:458:0:o;14101:716::-;14525:23;14551:69;14579:4;14551:69;;;;;;;;;;;;;;;;;14559:5;-1:-1:-1;;;;;14551:27:0;;;:69;;;;;:::i;:::-;14635:17;;14525:95;;-1:-1:-1;14635:21:0;14631:179;;14732:10;14721:30;;;;;;;;;;;;:::i;:::-;14713:85;;;;-1:-1:-1;;;14713:85:0;;8252:2:1;14713:85:0;;;8234:21:1;8291:2;8271:18;;;8264:30;8330:34;8310:18;;;8303:62;-1:-1:-1;;;8381:18:1;;;8374:40;8431:19;;14713:85:0;8050:406:1;6409:229:0;6546:12;6578:52;6600:6;6608:4;6614:1;6617:12;6578:21;:52::i;:::-;6571:59;;6409:229;;;;;;:::o;7529:510::-;7699:12;7757:5;7732:21;:30;;7724:81;;;;-1:-1:-1;;;7724:81:0;;8663:2:1;7724:81:0;;;8645:21:1;8702:2;8682:18;;;8675:30;8741:34;8721:18;;;8714:62;-1:-1:-1;;;8792:18:1;;;8785:36;8838:19;;7724:81:0;8461:402:1;7724:81:0;3926:20;;7816:60;;;;-1:-1:-1;;;7816:60:0;;9070:2:1;7816:60:0;;;9052:21:1;9109:2;9089:18;;;9082:30;9148:31;9128:18;;;9121:59;9197:18;;7816:60:0;8868:353:1;7816:60:0;7890:12;7904:23;7931:6;-1:-1:-1;;;;;7931:11:0;7950:5;7957:4;7931:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7889:73;;;;7980:51;7997:7;8006:10;8018:12;7980:16;:51::i;:::-;7973:58;7529:510;-1:-1:-1;;;;;;;7529:510:0:o;10215:712::-;10365:12;10394:7;10390:530;;;-1:-1:-1;10425:10:0;10418:17;;10390:530;10539:17;;:21;10535:374;;10737:10;10731:17;10798:15;10785:10;10781:2;10777:19;10770:44;10535:374;10880:12;10873:20;;-1:-1:-1;;;10873:20:0;;;;;;;;:::i;196:131:1:-;-1:-1:-1;;;;;271:31:1;;261:42;;251:70;;317:1;314;307:12;332:247;391:6;444:2;432:9;423:7;419:23;415:32;412:52;;;460:1;457;450:12;412:52;499:9;486:23;518:31;543:5;518:31;:::i;1057:127::-;1118:10;1113:3;1109:20;1106:1;1099:31;1149:4;1146:1;1139:15;1173:4;1170:1;1163:15;1189:275;1260:2;1254:9;1325:2;1306:13;;-1:-1:-1;;1302:27:1;1290:40;;1360:18;1345:34;;1381:22;;;1342:62;1339:88;;;1407:18;;:::i;:::-;1443:2;1436:22;1189:275;;-1:-1:-1;1189:275:1:o;1469:183::-;1529:4;1562:18;1554:6;1551:30;1548:56;;;1584:18;;:::i;:::-;-1:-1:-1;1629:1:1;1625:14;1641:4;1621:25;;1469:183::o;1657:662::-;1711:5;1764:3;1757:4;1749:6;1745:17;1741:27;1731:55;;1782:1;1779;1772:12;1731:55;1818:6;1805:20;1844:4;1868:60;1884:43;1924:2;1884:43;:::i;:::-;1868:60;:::i;:::-;1962:15;;;2048:1;2044:10;;;;2032:23;;2028:32;;;1993:12;;;;2072:15;;;2069:35;;;2100:1;2097;2090:12;2069:35;2136:2;2128:6;2124:15;2148:142;2164:6;2159:3;2156:15;2148:142;;;2230:17;;2218:30;;2268:12;;;;2181;;2148:142;;;-1:-1:-1;2308:5:1;1657:662;-1:-1:-1;;;;;;1657:662:1:o;2324:1215::-;2442:6;2450;2503:2;2491:9;2482:7;2478:23;2474:32;2471:52;;;2519:1;2516;2509:12;2471:52;2559:9;2546:23;2588:18;2629:2;2621:6;2618:14;2615:34;;;2645:1;2642;2635:12;2615:34;2683:6;2672:9;2668:22;2658:32;;2728:7;2721:4;2717:2;2713:13;2709:27;2699:55;;2750:1;2747;2740:12;2699:55;2786:2;2773:16;2808:4;2832:60;2848:43;2888:2;2848:43;:::i;2832:60::-;2926:15;;;3008:1;3004:10;;;;2996:19;;2992:28;;;2957:12;;;;3032:19;;;3029:39;;;3064:1;3061;3054:12;3029:39;3088:11;;;;3108:217;3124:6;3119:3;3116:15;3108:217;;;3204:3;3191:17;3221:31;3246:5;3221:31;:::i;:::-;3265:18;;3141:12;;;;3303;;;;3108:217;;;3344:5;-1:-1:-1;;3387:18:1;;3374:32;;-1:-1:-1;;3418:16:1;;;3415:36;;;3447:1;3444;3437:12;3415:36;;3470:63;3525:7;3514:8;3503:9;3499:24;3470:63;:::i;:::-;3460:73;;;2324:1215;;;;;:::o;3544:180::-;3603:6;3656:2;3644:9;3635:7;3631:23;3627:32;3624:52;;;3672:1;3669;3662:12;3624:52;-1:-1:-1;3695:23:1;;3544:180;-1:-1:-1;3544:180:1:o;3950:127::-;4011:10;4006:3;4002:20;3999:1;3992:31;4042:4;4039:1;4032:15;4066:4;4063:1;4056:15;4082:127;4143:10;4138:3;4134:20;4131:1;4124:31;4174:4;4171:1;4164:15;4198:4;4195:1;4188:15;4214:128;4254:3;4285:1;4281:6;4278:1;4275:13;4272:39;;;4291:18;;:::i;:::-;-1:-1:-1;4327:9:1;;4214:128::o;4347:135::-;4386:3;-1:-1:-1;;4407:17:1;;4404:43;;;4427:18;;:::i;:::-;-1:-1:-1;4474:1:1;4463:13;;4347:135::o;4898:125::-;4938:4;4966:1;4963;4960:8;4957:34;;;4971:18;;:::i;:::-;-1:-1:-1;5008:9:1;;4898:125::o;5028:356::-;5230:2;5212:21;;;5249:18;;;5242:30;5308:34;5303:2;5288:18;;5281:62;5375:2;5360:18;;5028:356::o;5389:184::-;5459:6;5512:2;5500:9;5491:7;5487:23;5483:32;5480:52;;;5528:1;5525;5518:12;5480:52;-1:-1:-1;5551:16:1;;5389:184;-1:-1:-1;5389:184:1:o;6328:168::-;6368:7;6434:1;6430;6426:6;6422:14;6419:1;6416:21;6411:1;6404:9;6397:17;6393:45;6390:71;;;6441:18;;:::i;:::-;-1:-1:-1;6481:9:1;;6328:168::o;6501:217::-;6541:1;6567;6557:132;;6611:10;6606:3;6602:20;6599:1;6592:31;6646:4;6643:1;6636:15;6674:4;6671:1;6664:15;6557:132;-1:-1:-1;6703:9:1;;6501:217::o;7768:277::-;7835:6;7888:2;7876:9;7867:7;7863:23;7859:32;7856:52;;;7904:1;7901;7894:12;7856:52;7936:9;7930:16;7989:5;7982:13;7975:21;7968:5;7965:32;7955:60;;8011:1;8008;8001:12;9226:258;9298:1;9308:113;9322:6;9319:1;9316:13;9308:113;;;9398:11;;;9392:18;9379:11;;;9372:39;9344:2;9337:10;9308:113;;;9439:6;9436:1;9433:13;9430:48;;;9474:1;9465:6;9460:3;9456:16;9449:27;9430:48;;9226:258;;;:::o;9489:274::-;9618:3;9656:6;9650:13;9672:53;9718:6;9713:3;9706:4;9698:6;9694:17;9672:53;:::i;:::-;9741:16;;;;;9489:274;-1:-1:-1;;9489:274:1:o;9768:383::-;9917:2;9906:9;9899:21;9880:4;9949:6;9943:13;9992:6;9987:2;9976:9;9972:18;9965:34;10008:66;10067:6;10062:2;10051:9;10047:18;10042:2;10034:6;10030:15;10008:66;:::i;:::-;10135:2;10114:15;-1:-1:-1;;10110:29:1;10095:45;;;;10142:2;10091:54;;9768:383;-1:-1:-1;;9768:383:1:o

ipfs://c7b5263bb0c484cc82094c2f231d31ea0f76d59576e250d25d852c8afd13d545