Contract 0xac7c023ee92f3d430aaeed835e7f25050fe231cc 1

/**
 *Submitted for verification at moonbeam.moonscan.io on 2022-02-07
*/

// File @openzeppelin/contracts/utils/[email protected]

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (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/access/[email protected]


// OpenZeppelin Contracts v4.4.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 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);
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]


// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts v4.4.0 (utils/Address.sol)

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    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);
            }
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]


// OpenZeppelin Contracts v4.4.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));
        }
    }

    /**
     * @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/math/[email protected]


// OpenZeppelin Contracts v4.4.0 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

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

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

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

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

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

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

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

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

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

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

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


// File contracts/vestings/Vesting.sol


pragma solidity ^0.8.6;
contract Vesting is Ownable {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    uint256 public startDate;
    uint256 internal constant PERIOD_LENGTH = 1 days;
    uint256 public immutable dailyVest;
    uint256 public immutable dailyVestLength;
    uint256 public totalShares;

    IERC20 internal immutable token;

    struct Recipient {
        uint256 withdrawnAmount;
        uint256 sharePerDay;
    }

    uint256 public totalRecipients;
    mapping(address => Recipient) public recipients;

    event LogStartDateSet(address setter, uint256 startDate);
    event LogRecipientAdded(address recipient, uint256 dailyShare);
    event LogTokensClaimed(address recipient, uint256 amount);

    modifier onlyValidShareAmount(uint256 _dailyShare) {
        require(
            _dailyShare <= dailyVest,
            "daily share must be less than daily vest"
        );
        _;
    }

    constructor(
        IERC20 _token,
        uint256 _dailyVest,
        uint256 _dailyVestLength
    ) {
        token = _token;
        dailyVest = _dailyVest;
        dailyVestLength = _dailyVestLength;
    }

    function percDiv(
        uint256 period,
        uint256 _share
    ) public pure returns (uint256) {
        return period.mul(_share);
    }

    function setStartDate(uint256 _startDate) public onlyOwner {
        require(
            _startDate >= block.timestamp,
            "Start Date can't be in the past"
        );
        require(startDate == 0,"Vesting already started");
        startDate = _startDate;
        emit LogStartDateSet(address(msg.sender), _startDate);
    }

    function addRecipient(address _recipientAddress, uint256 _dailyShare)
        public
        onlyOwner
        onlyValidShareAmount(_dailyShare)
    {
        uint256 savedShare = recipients[_recipientAddress].sharePerDay;
        totalShares = totalShares + _dailyShare;
        totalRecipients++;

        recipients[_recipientAddress] = Recipient(0, savedShare +_dailyShare);
        emit LogRecipientAdded(_recipientAddress,savedShare+ _dailyShare);
    }

    function updateUser(address _recipientAddress, uint256 _dailyShare)
        external
        onlyOwner
    {
        uint256 oldUserShare = recipients[_recipientAddress].sharePerDay;
        totalShares = totalShares + _dailyShare - oldUserShare;
        recipients[_recipientAddress].sharePerDay = _dailyShare;
    }

    function addMultipleRecipients(
        address[] calldata _recipients,
        uint256[] calldata _dailyShares
    ) public onlyOwner {
        require(
            _recipients.length < 200,
            "The recipients array size must be smaller than 200"
        );
        require(
            _recipients.length == _dailyShares.length,
            "The two arrays are with different length"
        );
        for (uint256 i; i < _recipients.length; i++) {
            addRecipient(_recipients[i], _dailyShares[i]);
        }
    }

    function claim() external {
        require(startDate != 0, "The vesting hasn't started");
        require(block.timestamp >= startDate, "The vesting hasn't started");

        (uint256 owedAmount, uint256 calculatedAmount) = calculateAmounts();
        recipients[msg.sender].withdrawnAmount = calculatedAmount;
        token.safeTransfer(msg.sender, owedAmount);
        emit LogTokensClaimed(msg.sender, owedAmount);
    }

    function hasClaim() public view returns (uint256) {
        if (block.timestamp < startDate) {
            return 0;
        }

        (uint256 owedAmount, uint256 calculatedAmount) = calculateAmounts();
        return owedAmount;
    }

    function calculateAmounts()
        internal
        view
        returns (uint256 _owedAmount, uint256 _calculatedAmount)
    {
        uint256 period = (block.timestamp - startDate) / (PERIOD_LENGTH);
        if (period >= dailyVestLength) {
            period = dailyVestLength;
        } else {
            period = period + 1;
        }
        _calculatedAmount = percDiv(
            period,
            recipients[msg.sender].sharePerDay
        );
        _owedAmount =
            _calculatedAmount -
            recipients[msg.sender].withdrawnAmount;

        return (_owedAmount, _calculatedAmount);
    }

    function rescueTokens(IERC20 _token, uint256 _amount)
        external
        onlyOwner
    {
        require(address(_token) != address(token),"cant rescue vested token");
        _token.safeTransfer(msg.sender, _amount);
    }
}

[{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"_dailyVest","type":"uint256"},{"internalType":"uint256","name":"_dailyVestLength","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"dailyShare","type":"uint256"}],"name":"LogRecipientAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"setter","type":"address"},{"indexed":false,"internalType":"uint256","name":"startDate","type":"uint256"}],"name":"LogStartDateSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogTokensClaimed","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"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"uint256[]","name":"_dailyShares","type":"uint256[]"}],"name":"addMultipleRecipients","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipientAddress","type":"address"},{"internalType":"uint256","name":"_dailyShare","type":"uint256"}],"name":"addRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dailyVest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dailyVestLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"period","type":"uint256"},{"internalType":"uint256","name":"_share","type":"uint256"}],"name":"percDiv","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"recipients","outputs":[{"internalType":"uint256","name":"withdrawnAmount","type":"uint256"},{"internalType":"uint256","name":"sharePerDay","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"rescueTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startDate","type":"uint256"}],"name":"setStartDate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRecipients","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipientAddress","type":"address"},{"internalType":"uint256","name":"_dailyShare","type":"uint256"}],"name":"updateUser","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000cd3b51d98478d53f4515a306be565c6eebef1d580000000000000000000000000000000000000000000052392278ea01bb000000000000000000000000000000000000000000000000000000000000000000016d

-----Decoded View---------------
Arg [0] : _token (address): 0xcd3b51d98478d53f4515a306be565c6eebef1d58
Arg [1] : _dailyVest (uint256): 388288000000000000000000
Arg [2] : _dailyVestLength (uint256): 365

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000cd3b51d98478d53f4515a306be565c6eebef1d58
Arg [1] : 0000000000000000000000000000000000000000000052392278ea01bb000000
Arg [2] : 000000000000000000000000000000000000000000000000000000000000016d

25634:4622:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25735:24;;;;;;;;;160:25:1;;;148:2;133:18;25735:24:0;;;;;;;;28121:550;;;;;;:::i;:::-;;:::i;:::-;;25821:34;;;;;25909:26;;;;;;29120:244;;;:::i;28679:433::-;;;:::i;30018:235::-;;;;;;:::i;:::-;;:::i;26802:148::-;;;;;;:::i;:::-;;:::i;2649:103::-;;;:::i;26958:345::-;;;;;;:::i;:::-;;:::i;1998:87::-;2044:7;2071:6;1998:87;;-1:-1:-1;;;;;2071:6:0;;;2439:74:1;;2427:2;2412:18;1998:87:0;2293:226:1;27789:324:0;;;;;;:::i;:::-;;:::i;25862:40::-;;;;;26118:47;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;3286:25:1;;;3342:2;3327:18;;3320:34;;;;3259:18;26118:47:0;3112:248:1;2907:201:0;;;;;;:::i;:::-;;:::i;26081:30::-;;;;;;27311:470;;;;;;:::i;:::-;;:::i;28121:550::-;2044:7;2071:6;-1:-1:-1;;;;;2071:6:0;796:10;2218:23;2210:68;;;;-1:-1:-1;;;2210:68:0;;3567:2:1;2210:68:0;;;3549:21:1;;;3586:18;;;3579:30;3645:34;3625:18;;;3618:62;3697:18;;2210:68:0;;;;;;;;;28313:3:::1;28292:24:::0;::::1;28270:124;;;::::0;-1:-1:-1;;;28270:124:0;;3928:2:1;28270:124:0::1;::::0;::::1;3910:21:1::0;3967:2;3947:18;;;3940:30;4006:34;3986:18;;;3979:62;4077:20;4057:18;;;4050:48;4115:19;;28270:124:0::1;3726:414:1::0;28270:124:0::1;28427:41:::0;;::::1;28405:131;;;::::0;-1:-1:-1;;;28405:131:0;;4347:2:1;28405:131:0::1;::::0;::::1;4329:21:1::0;4386:2;4366:18;;;4359:30;4425:34;4405:18;;;4398:62;4496:10;4476:18;;;4469:38;4524:19;;28405:131:0::1;4145:404:1::0;28405:131:0::1;28552:9;28547:117;28563:22:::0;;::::1;28547:117;;;28607:45;28620:11;;28632:1;28620:14;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;28636:12;;28649:1;28636:15;;;;;;;:::i;:::-;;;;;;;28607:12;:45::i;:::-;28587:3:::0;::::1;::::0;::::1;:::i;:::-;;;;28547:117;;;;28121:550:::0;;;;:::o;29120:244::-;29161:7;29203:9;;29185:15;:27;29181:68;;;-1:-1:-1;29236:1:0;;29120:244::o;29181:68::-;29262:18;29282:24;29310:18;:16;:18::i;:::-;-1:-1:-1;29261:67:0;29120:244;-1:-1:-1;;;29120:244:0:o;28679:433::-;28724:9;;28716:53;;;;-1:-1:-1;;;28716:53:0;;5274:2:1;28716:53:0;;;5256:21:1;5313:2;5293:18;;;5286:30;5352:28;5332:18;;;5325:56;5398:18;;28716:53:0;5072:350:1;28716:53:0;28807:9;;28788:15;:28;;28780:67;;;;-1:-1:-1;;;28780:67:0;;5274:2:1;28780:67:0;;;5256:21:1;5313:2;5293:18;;;5286:30;5352:28;5332:18;;;5325:56;5398:18;;28780:67:0;5072:350:1;28780:67:0;28861:18;28881:24;28909:18;:16;:18::i;:::-;28949:10;28938:22;;;;:10;:22;;;;;:57;;;28860:67;;-1:-1:-1;28860:67:0;-1:-1:-1;29006:42:0;;:5;-1:-1:-1;;;;;29006:18:0;;28860:67;29006:18;:42::i;:::-;29064:40;;;29081:10;5601:74:1;;5706:2;5691:18;;5684:34;;;29064:40:0;;5574:18:1;29064:40:0;;;;;;;28705:407;;28679:433::o;30018:235::-;2044:7;2071:6;-1:-1:-1;;;;;2071:6:0;796:10;2218:23;2210:68;;;;-1:-1:-1;;;2210:68:0;;3567:2:1;2210:68:0;;;3549:21:1;;;3586:18;;;3579:30;3645:34;3625:18;;;3618:62;3697:18;;2210:68:0;3365:356:1;2210:68:0;30160:5:::1;-1:-1:-1::0;;;;;30133:33:0::1;30141:6;-1:-1:-1::0;;;;;30133:33:0::1;;;30125:69;;;::::0;-1:-1:-1;;;30125:69:0;;5931:2:1;30125:69:0::1;::::0;::::1;5913:21:1::0;5970:2;5950:18;;;5943:30;6009:26;5989:18;;;5982:54;6053:18;;30125:69:0::1;5729:348:1::0;30125:69:0::1;30205:40;-1:-1:-1::0;;;;;30205:19:0;::::1;30225:10;30237:7:::0;30205:19:::1;:40::i;:::-;30018:235:::0;;:::o;26802:148::-;26897:7;26924:18;:6;26935;26924:10;:18::i;:::-;26917:25;26802:148;-1:-1:-1;;;26802:148:0:o;2649:103::-;2044:7;2071:6;-1:-1:-1;;;;;2071:6:0;796:10;2218:23;2210:68;;;;-1:-1:-1;;;2210:68:0;;3567:2:1;2210:68:0;;;3549:21:1;;;3586:18;;;3579:30;3645:34;3625:18;;;3618:62;3697:18;;2210:68:0;3365:356:1;2210:68:0;2714:30:::1;2741:1;2714:18;:30::i;:::-;2649:103::o:0;26958:345::-;2044:7;2071:6;-1:-1:-1;;;;;2071:6:0;796:10;2218:23;2210:68;;;;-1:-1:-1;;;2210:68:0;;3567:2:1;2210:68:0;;;3549:21:1;;;3586:18;;;3579:30;3645:34;3625:18;;;3618:62;3697:18;;2210:68:0;3365:356:1;2210:68:0;27064:15:::1;27050:10;:29;;27028:110;;;::::0;-1:-1:-1;;;27028:110:0;;6284:2:1;27028:110:0::1;::::0;::::1;6266:21:1::0;6323:2;6303:18;;;6296:30;6362:33;6342:18;;;6335:61;6413:18;;27028:110:0::1;6082:355:1::0;27028:110:0::1;27157:9;::::0;:14;27149:49:::1;;;::::0;-1:-1:-1;;;27149:49:0;;6644:2:1;27149:49:0::1;::::0;::::1;6626:21:1::0;6683:2;6663:18;;;6656:30;6722:25;6702:18;;;6695:53;6765:18;;27149:49:0::1;6442:347:1::0;27149:49:0::1;27209:9;:22:::0;;;27247:48:::1;::::0;;27271:10:::1;5601:74:1::0;;5706:2;5691:18;;5684:34;;;27247:48:0::1;::::0;5574:18:1;27247:48:0::1;;;;;;;26958:345:::0;:::o;27789:324::-;2044:7;2071:6;-1:-1:-1;;;;;2071:6:0;796:10;2218:23;2210:68;;;;-1:-1:-1;;;2210:68:0;;3567:2:1;2210:68:0;;;3549:21:1;;;3586:18;;;3579:30;3645:34;3625:18;;;3618:62;3697:18;;2210:68:0;3365:356:1;2210:68:0;-1:-1:-1;;;;;27933:29:0;::::1;27910:20;27933:29:::0;;;:10:::1;:29;::::0;;;;:41:::1;;::::0;27999:11:::1;::::0;27933:41;;27999:25:::1;::::0;28013:11;;27999:25:::1;:::i;:::-;:40;;;;:::i;:::-;27985:11;:54:::0;-1:-1:-1;;;;;;28050:29:0;;::::1;;::::0;;;:10:::1;:29;::::0;;;;:41:::1;;:55:::0;27789:324::o;2907:201::-;2044:7;2071:6;-1:-1:-1;;;;;2071:6:0;796:10;2218:23;2210:68;;;;-1:-1:-1;;;2210:68:0;;3567:2:1;2210:68:0;;;3549:21:1;;;3586:18;;;3579:30;3645:34;3625:18;;;3618:62;3697:18;;2210:68:0;3365:356:1;2210:68:0;-1:-1:-1;;;;;2996:22:0;::::1;2988:73;;;::::0;-1:-1:-1;;;2988:73:0;;7259:2:1;2988:73:0::1;::::0;::::1;7241:21:1::0;7298:2;7278:18;;;7271:30;7337:34;7317:18;;;7310:62;7408:8;7388:18;;;7381:36;7434:19;;2988:73:0::1;7057:402:1::0;2988:73:0::1;3072:28;3091:8;3072:18;:28::i;:::-;2907:201:::0;:::o;27311:470::-;2044:7;2071:6;-1:-1:-1;;;;;2071:6:0;796:10;2218:23;2210:68;;;;-1:-1:-1;;;2210:68:0;;3567:2:1;2210:68:0;;;3549:21:1;;;3586:18;;;3579:30;3645:34;3625:18;;;3618:62;3697:18;;2210:68:0;3365:356:1;2210:68:0;27446:11:::1;26471:9;26456:11;:24;;26434:114;;;::::0;-1:-1:-1;;;26434:114:0;;7666:2:1;26434:114:0::1;::::0;::::1;7648:21:1::0;7705:2;7685:18;;;7678:30;7744:34;7724:18;;;7717:62;7815:10;7795:18;;;7788:38;7843:19;;26434:114:0::1;7464:404:1::0;26434:114:0::1;-1:-1:-1::0;;;;;27496:29:0;::::2;27475:18;27496:29:::0;;;:10:::2;:29;::::0;;;;:41:::2;;::::0;27562:11:::2;::::0;:25:::2;::::0;27576:11;;27562:25:::2;:::i;:::-;27548:11;:39:::0;27598:15:::2;:17:::0;;;:15:::2;:17;::::0;::::2;:::i;:::-;;;;;;27660:37;;;;;;;;27670:1;27660:37;;;;27685:11;27673:10;:23;;;;:::i;:::-;27660:37:::0;;-1:-1:-1;;;;;27628:29:0;::::2;;::::0;;;:10:::2;:29;::::0;;;;;;;:69;;;;;::::2;::::0;::::2;::::0;;::::2;::::0;27713:60:::2;27639:17:::0;27749:23:::2;27761:11:::0;27749:10;:23:::2;:::i;:::-;27713:60;::::0;;-1:-1:-1;;;;;5619:55:1;;;5601:74;;5706:2;5691:18;;5684:34;;;;5574:18;27713:60:0::2;;;;;;;27464:317;2289:1:::1;27311:470:::0;;:::o;29372:638::-;29450:19;29471:25;29514:14;25808:6;29550:9;;29532:15;:27;;;;:::i;:::-;29531:47;;;;:::i;:::-;29514:64;;29603:15;29593:6;:25;29589:134;;-1:-1:-1;29644:15:0;29589:134;;;29701:10;:6;29710:1;29701:10;:::i;:::-;29692:19;;29589:134;29807:10;29796:22;;;;:10;:22;;;;;:34;;;29753:88;;29775:6;;29753:7;:88::i;:::-;29923:10;29912:22;;;;:10;:22;;;;;:38;29733:108;;-1:-1:-1;29879:71:0;;29733:108;29879:71;:::i;:::-;29852:98;;29963:39;29372:638;;:::o;15232:211::-;15376:58;;;-1:-1:-1;;;;;5619:55:1;;15376:58:0;;;5601:74:1;5691:18;;;;5684:34;;;15376:58:0;;;;;;;;;;5574:18:1;;;;15376:58:0;;;;;;;;;;15399:23;15376:58;;;15349:86;;15369:5;;15349:19;:86::i;:::-;15232:211;;;:::o;22136:98::-;22194:7;22221:5;22225:1;22221;:5;:::i;3268:191::-;3342:16;3361:6;;-1:-1:-1;;;;;3378:17:0;;;;;;;;;;3411:40;;3361:6;;;;;;;3411:40;;3342:16;3411:40;3331:128;3268:191;:::o;17805:716::-;18229:23;18255:69;18283:4;18255:69;;;;;;;;;;;;;;;;;18263:5;-1:-1:-1;;;;;18255:27:0;;;:69;;;;;:::i;:::-;18339:17;;18229:95;;-1:-1:-1;18339:21:0;18335:179;;18436:10;18425:30;;;;;;;;;;;;:::i;:::-;18417:85;;;;-1:-1:-1;;;18417:85:0;;8809:2:1;18417:85:0;;;8791:21:1;8848:2;8828:18;;;8821:30;8887:34;8867:18;;;8860:62;8958:12;8938:18;;;8931:40;8988:19;;18417:85:0;8607:406:1;10004:229:0;10141:12;10173:52;10195:6;10203:4;10209:1;10212:12;10173:21;:52::i;:::-;10166:59;10004:229;-1:-1:-1;;;;10004:229:0:o;11124:510::-;11294:12;11352:5;11327:21;:30;;11319:81;;;;-1:-1:-1;;;11319:81:0;;9220:2:1;11319:81:0;;;9202:21:1;9259:2;9239:18;;;9232:30;9298:34;9278:18;;;9271:62;9369:8;9349:18;;;9342:36;9395:19;;11319:81:0;9018:402:1;11319:81:0;7521:20;;11411:60;;;;-1:-1:-1;;;11411:60:0;;9627:2:1;11411:60:0;;;9609:21:1;9666:2;9646:18;;;9639:30;9705:31;9685:18;;;9678:59;9754:18;;11411:60:0;9425:353:1;11411:60:0;11485:12;11499:23;11526:6;-1:-1:-1;;;;;11526:11:0;11545:5;11552:4;11526:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11484:73;;;;11575:51;11592:7;11601:10;11613:12;11575:16;:51::i;:::-;11568:58;11124:510;-1:-1:-1;;;;;;;11124:510:0:o;13810:712::-;13960:12;13989:7;13985:530;;;-1:-1:-1;14020:10:0;14013:17;;13985:530;14134:17;;:21;14130:374;;14332:10;14326:17;14393:15;14380:10;14376:2;14372:19;14365:44;14130:374;14475:12;14468:20;;-1:-1:-1;;;14468:20:0;;;;;;;;:::i;196:367:1:-;259:8;269:6;323:3;316:4;308:6;304:17;300:27;290:55;;341:1;338;331:12;290:55;-1:-1:-1;364:20:1;;407:18;396:30;;393:50;;;439:1;436;429:12;393:50;476:4;468:6;464:17;452:29;;536:3;529:4;519:6;516:1;512:14;504:6;500:27;496:38;493:47;490:67;;;553:1;550;543:12;490:67;196:367;;;;;:::o;568:773::-;690:6;698;706;714;767:2;755:9;746:7;742:23;738:32;735:52;;;783:1;780;773:12;735:52;823:9;810:23;852:18;893:2;885:6;882:14;879:34;;;909:1;906;899:12;879:34;948:70;1010:7;1001:6;990:9;986:22;948:70;:::i;:::-;1037:8;;-1:-1:-1;922:96:1;-1:-1:-1;1125:2:1;1110:18;;1097:32;;-1:-1:-1;1141:16:1;;;1138:36;;;1170:1;1167;1160:12;1138:36;;1209:72;1273:7;1262:8;1251:9;1247:24;1209:72;:::i;:::-;568:773;;;;-1:-1:-1;1300:8:1;-1:-1:-1;;;;568:773:1:o;1346:162::-;-1:-1:-1;;;;;1433:5:1;1429:54;1422:5;1419:65;1409:93;;1498:1;1495;1488:12;1513:337;1595:6;1603;1656:2;1644:9;1635:7;1631:23;1627:32;1624:52;;;1672:1;1669;1662:12;1624:52;1711:9;1698:23;1730:39;1763:5;1730:39;:::i;:::-;1788:5;1840:2;1825:18;;;;1812:32;;-1:-1:-1;;;1513:337:1:o;1855:248::-;1923:6;1931;1984:2;1972:9;1963:7;1959:23;1955:32;1952:52;;;2000:1;1997;1990:12;1952:52;-1:-1:-1;;2023:23:1;;;2093:2;2078:18;;;2065:32;;-1:-1:-1;1855:248:1:o;2108:180::-;2167:6;2220:2;2208:9;2199:7;2195:23;2191:32;2188:52;;;2236:1;2233;2226:12;2188:52;-1:-1:-1;2259:23:1;;2108:180;-1:-1:-1;2108:180:1:o;2852:255::-;2911:6;2964:2;2952:9;2943:7;2939:23;2935:32;2932:52;;;2980:1;2977;2970:12;2932:52;3019:9;3006:23;3038:39;3071:5;3038:39;:::i;4554:184::-;-1:-1:-1;;;4603:1:1;4596:88;4703:4;4700:1;4693:15;4727:4;4724:1;4717:15;4743:184;-1:-1:-1;;;4792:1:1;4785:88;4892:4;4889:1;4882:15;4916:4;4913:1;4906:15;4932:135;4971:3;-1:-1:-1;;4992:17:1;;4989:43;;;5012:18;;:::i;:::-;-1:-1:-1;5059:1:1;5048:13;;4932:135::o;6794:128::-;6834:3;6865:1;6861:6;6858:1;6855:13;6852:39;;;6871:18;;:::i;:::-;-1:-1:-1;6907:9:1;;6794:128::o;6927:125::-;6967:4;6995:1;6992;6989:8;6986:34;;;7000:18;;:::i;:::-;-1:-1:-1;7037:9:1;;6927:125::o;7873:274::-;7913:1;7939;7929:189;;-1:-1:-1;;;7971:1:1;7964:88;8075:4;8072:1;8065:15;8103:4;8100:1;8093:15;7929:189;-1:-1:-1;8132:9:1;;7873:274::o;8152:168::-;8192:7;8258:1;8254;8250:6;8246:14;8243:1;8240:21;8235:1;8228:9;8221:17;8217:45;8214:71;;;8265:18;;:::i;:::-;-1:-1:-1;8305:9:1;;8152:168::o;8325:277::-;8392:6;8445:2;8433:9;8424:7;8420:23;8416:32;8413:52;;;8461:1;8458;8451:12;8413:52;8493:9;8487:16;8546:5;8539:13;8532:21;8525:5;8522:32;8512:60;;8568:1;8565;8558:12;9783:258;9855:1;9865:113;9879:6;9876:1;9873:13;9865:113;;;9955:11;;;9949:18;9936:11;;;9929:39;9901:2;9894:10;9865:113;;;9996:6;9993:1;9990:13;9987:48;;;10031:1;10022:6;10017:3;10013:16;10006:27;9987:48;;9783:258;;;:::o;10046:274::-;10175:3;10213:6;10207:13;10229:53;10275:6;10270:3;10263:4;10255:6;10251:17;10229:53;:::i;:::-;10298:16;;;;;10046:274;-1:-1:-1;;10046:274:1:o;10325:383::-;10474:2;10463:9;10456:21;10437:4;10506:6;10500:13;10549:6;10544:2;10533:9;10529:18;10522:34;10565:66;10624:6;10619:2;10608:9;10604:18;10599:2;10591:6;10587:15;10565:66;:::i;:::-;10692:2;10671:15;-1:-1:-1;;10667:29:1;10652:45;;;;10699:2;10648:54;;10325:383;-1:-1:-1;;10325:383:1:o

ipfs://2e3048f23bc6583472e5c2d540a604a2d707fa080efb2ef5b1fd37b1c116747c