Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: Unlicense
pragma solidity = 0.8.9;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/// @title Stablz vesting contract
contract StablzVesting is Ownable, ReentrancyGuard {

    using SafeERC20 for IERC20;

    IERC20 public stablz;

    uint constant private TGE_PERCENT_DENOMINATOR = 100;

    uint public vestingStartedAt;

    uint public totalAmount;
    uint public totalWithdrawn;

    struct Vestment {
        uint amount;
        uint withdrawn;
        uint period;
        /// @dev tgeAmount refers to the amount that the user is allowed to withdraw at TGE
        uint tgeAmount;
        bool isTGEAmountWithdrawn;
    }

    struct User {
        uint numberOfVestments;
        mapping(uint => Vestment) vestments;
    }

    mapping(address => User) private _users;

    event Withdrawn(address user, uint amount);
    event VestingPeriodStarted();

    /// @param _user User address
    /// @param _vestmentId Vestment ID
    modifier onlyValidVestmentId(address _user, uint _vestmentId) {
        uint numberOfVestments = _users[_user].numberOfVestments;
        require(numberOfVestments > 0, "StablzVesting: No vestments found for user");
        require(_vestmentId < numberOfVestments, "StablzVesting: Invalid vestment ID");
        _;
    }

    /// @notice Import vesting data
    /// @param _addresses List of addresses
    /// @param _amounts List of amounts
    /// @param _tgePercent TGE percentage e.g. 20 is 20%
    /// @param _vestingPeriod Vesting period in seconds e.g. 2592000 is 30 days
    function importData(address[] calldata _addresses, uint[] calldata _amounts, uint _tgePercent, uint _vestingPeriod) external onlyOwner {
        require(!_hasVestingStarted(), "StablzVesting: Cannot import data after vesting has started");
        require(_addresses.length == _amounts.length, "StablzVesting: _addresses and _amounts list lengths do not match");
        require(_tgePercent < TGE_PERCENT_DENOMINATOR, "StablzVesting: _tgePercent must be less than 100");
        uint total;
        for (uint i; i < _addresses.length; i++) {
            total += _amounts[i];
            User storage user = _users[_addresses[i]];

            uint tgeAmount;
            if (_tgePercent > 0) {
                tgeAmount = _amounts[i] * _tgePercent / TGE_PERCENT_DENOMINATOR;
            }
            uint vested = _amounts[i] - tgeAmount;
            user.vestments[user.numberOfVestments] = Vestment(
                vested,
                0,
                _vestingPeriod,
                tgeAmount,
                false
            );
            user.numberOfVestments++;
        }
        totalAmount += total;
    }

    /// @notice Start vesting period
    /// @param _stablz Stablz token address
    function startVestingPeriod(IERC20 _stablz) external onlyOwner {
        require(address(_stablz) != address(0), "StablzVesting: _stablz cannot be the zero address");
        require(!_hasVestingStarted(), "StablzVesting: Vesting period has already started");
        require(totalAmount > 0, "StablzVesting: No data has been configured");
        stablz = _stablz;
        vestingStartedAt = block.timestamp;
        stablz.safeTransferFrom(_msgSender(), address(this), totalAmount);
        emit VestingPeriodStarted();
    }

    /// @notice Withdraw Stablz tokens
    function withdraw(uint _vestmentId) external nonReentrant onlyValidVestmentId(_msgSender(), _vestmentId) {
        require(_hasVestingStarted(), "StablzVesting: Unlock period has not started");
        User storage user = _users[_msgSender()];
        Vestment storage vestment = user.vestments[_vestmentId];
        bool unclaimedTGE = !vestment.isTGEAmountWithdrawn && vestment.tgeAmount > 0;
        bool unclaimedVestment = vestment.withdrawn < vestment.amount;
        require(unclaimedTGE || unclaimedVestment, "StablzVesting: You have already withdrawn the total amount");
        uint amount;
        if (unclaimedTGE) {
            vestment.isTGEAmountWithdrawn = true;
            amount += vestment.tgeAmount;
        }
        uint available = _availableToWithdraw(vestment);
        vestment.withdrawn += available;
        amount += available;
        totalWithdrawn += amount;
        stablz.safeTransfer(_msgSender(), amount);
        emit Withdrawn(_msgSender(), amount);
    }

    /// @notice Get the number of vestments for a user
    /// @param _user User address
    /// @return uint The total number of user vestments
    function getNumberOfVestments(address _user) external view returns (uint) {
        return _users[_user].numberOfVestments;
    }

    /// @notice Get details about a vestment for a given user and vestment ID
    /// @param _user User address
    /// @param _vestmentId Vestment ID
    /// @return Vestment A user's vestment
    function getVestment(address _user, uint _vestmentId) external view onlyValidVestmentId(_user, _vestmentId) returns (Vestment memory) {
        return _users[_user].vestments[_vestmentId];
    }

    /// @dev Calculate amount to withdraw based on the current time relative to the vesting period
    /// @param _vestment Vestment
    /// @return amount Available amount to withdraw for a given vestment
    function _availableToWithdraw(Vestment memory _vestment) internal view returns (uint amount) {
        uint endDate = vestingStartedAt + _vestment.period;
        if (block.timestamp >= endDate) {
            amount = _vestment.amount - _vestment.withdrawn;
        } else {
            uint timeDifference = block.timestamp - vestingStartedAt;
            amount = (_vestment.amount * timeDifference / _vestment.period) - _vestment.withdrawn;
        }
    }

    /// @dev Checks whether or not the vesting period has started
    /// @return bool true if vesting has started, false if not
    function _hasVestingStarted() internal view returns (bool) {
        return vestingStartedAt > 0;
    }
}

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

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

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

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

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

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

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

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

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

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

pragma solidity ^0.8.0;

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

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

{
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":[],"name":"VestingPeriodStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getNumberOfVestments","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_vestmentId","type":"uint256"}],"name":"getVestment","outputs":[{"components":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"withdrawn","type":"uint256"},{"internalType":"uint256","name":"period","type":"uint256"},{"internalType":"uint256","name":"tgeAmount","type":"uint256"},{"internalType":"bool","name":"isTGEAmountWithdrawn","type":"bool"}],"internalType":"struct StablzVesting.Vestment","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"},{"internalType":"uint256","name":"_tgePercent","type":"uint256"},{"internalType":"uint256","name":"_vestingPeriod","type":"uint256"}],"name":"importData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stablz","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_stablz","type":"address"}],"name":"startVestingPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalWithdrawn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vestingStartedAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_vestmentId","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

339:5770:7:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;550:23;;;;;;;;;160:25:8;;;148:2;133:18;550:23:7;;;;;;;;1745:1126;;;;;;:::i;:::-;;:::i;:::-;;3530:994;;;;;;:::i;:::-;;:::i;579:26::-;;;;;;430:20;;;;;-1:-1:-1;;;;;430:20:7;;;;;;-1:-1:-1;;;;;1846:55:8;;;1828:74;;1816:2;1801:18;430:20:7;1668:240:8;5004:194:7;;;;;;:::i;:::-;;:::i;:::-;;;;;;2534:4:8;2576:3;2565:9;2561:19;2553:27;;2613:6;2607:13;2596:9;2589:32;2677:4;2669:6;2665:17;2659:24;2652:4;2641:9;2637:20;2630:54;2740:4;2732:6;2728:17;2722:24;2715:4;2704:9;2700:20;2693:54;2803:4;2795:6;2791:17;2785:24;2778:4;2767:9;2763:20;2756:54;2880:4;2872:6;2868:17;2862:24;2855:32;2848:40;2841:4;2830:9;2826:20;2819:70;2392:503;;;;;1831:101:0;;;:::i;1201:85::-;1247:7;1273:6;-1:-1:-1;;;;;1273:6:0;1201:85;;4675:129:7;;;;;;:::i;:::-;-1:-1:-1;;;;;4766:13:7;4743:4;4766:13;;;:6;:13;;;;;:31;;4675:129;515:28;;;;;;2958:527;;;;;;:::i;:::-;;:::i;2081:198:0:-;;;;;;:::i;:::-;;:::i;1745:1126:7:-;1094:13:0;:11;:13::i;:::-;6080:16:7;;:20;1890:93:::1;;;::::0;-1:-1:-1;;;1890:93:7;;3851:2:8;1890:93:7::1;::::0;::::1;3833:21:8::0;3890:2;3870:18;;;3863:30;3929:34;3909:18;;;3902:62;4000:29;3980:18;;;3973:57;4047:19;;1890:93:7::1;;;;;;;;;2001:36:::0;;::::1;1993:113;;;::::0;;-1:-1:-1;;;1993:113:7;;4279:2:8;1993:113:7::1;::::0;::::1;4261:21:8::0;4298:18;;;4291:30;;;;4357:34;4337:18;;;4330:62;4428:34;4408:18;;;4401:62;4480:19;;1993:113:7::1;4077:428:8::0;1993:113:7::1;505:3;2124:11;:37;2116:98;;;::::0;-1:-1:-1;;;2116:98:7;;4712:2:8;2116:98:7::1;::::0;::::1;4694:21:8::0;4751:2;4731:18;;;4724:30;4790:34;4770:18;;;4763:62;4861:18;4841;;;4834:46;4897:19;;2116:98:7::1;4510:412:8::0;2116:98:7::1;2224:10;2249:6:::0;2244:591:::1;2257:21:::0;;::::1;2244:591;;;2308:8;;2317:1;2308:11;;;;;;;:::i;:::-;;;;;;;2299:20;;;;;:::i;:::-;;;2333:17;2353:6;:21;2360:10;;2371:1;2360:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;2353:21:7::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;2353:21:7;;;;-1:-1:-1;2421:15:7;;2417:117:::1;;505:3;2482:11;2468:8;;2477:1;2468:11;;;;;;;:::i;:::-;;;;;;;:25;;;;:::i;:::-;:51;;;;:::i;:::-;2456:63;;2417:117;2547:11;2575:9;2561:8;;2570:1;2561:11;;;;;;;:::i;:::-;;;;;;;:23;;;;:::i;:::-;2639:147;::::0;;::::1;::::0;::::1;::::0;;;;;-1:-1:-1;2639:147:7::1;::::0;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;2613:22;;2598:38;;2639:147;2598:14;;::::1;:38:::0;;;;;;:188;;;;;;;;::::1;::::0;;;;;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;2598:188:7::1;::::0;::::1;;::::0;;;::::1;::::0;;2800:24;;2639:147;;-1:-1:-1;2613:22:7;;2800:24:::1;::::0;::::1;:::i;:::-;;;;;;2285:550;;;2280:3;;;;;:::i;:::-;;;;2244:591;;;;2859:5;2844:11;;:20;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;;;1745:1126:7:o;3530:994::-;2261:21:1;:19;:21::i;:::-;719:10:6;1234:22:7::1;1259:13:::0;;;:6:::1;:13;::::0;;;;:31;3622:11;;1259:31;1300:76:::1;;;::::0;-1:-1:-1;;;1300:76:7;;6362:2:8;1300:76:7::1;::::0;::::1;6344:21:8::0;6401:2;6381:18;;;6374:30;6440:34;6420:18;;;6413:62;-1:-1:-1;;;6491:18:8;;;6484:40;6541:19;;1300:76:7::1;6160:406:8::0;1300:76:7::1;1408:17;1394:11;:31;1386:78;;;::::0;-1:-1:-1;;;1386:78:7;;6773:2:8;1386:78:7::1;::::0;::::1;6755:21:8::0;6812:2;6792:18;;;6785:30;6851:34;6831:18;;;6824:62;-1:-1:-1;;;6902:18:8;;;6895:32;6944:19;;1386:78:7::1;6571:398:8::0;1386:78:7::1;6080:16:::0;;3645:77:::2;;;::::0;-1:-1:-1;;;3645:77:7;;7176:2:8;3645:77:7::2;::::0;::::2;7158:21:8::0;7215:2;7195:18;;;7188:30;7254:34;7234:18;;;7227:62;7325:14;7305:18;;;7298:42;7357:19;;3645:77:7::2;6974:408:8::0;3645:77:7::2;719:10:6::0;3732:17:7::2;3752:20:::0;;;:6:::2;:20;::::0;;;;;;;3810:27;;;:14:::2;::::0;::::2;:27:::0;;;;;3868:29:::2;::::0;::::2;::::0;3752:20;;3810:27;;3868:29:::2;;3867:30;:56:::0;::::2;;;;3922:1;3901:8;:18;;;:22;3867:56;3979:15:::0;;3958:18:::2;::::0;::::2;::::0;3847:76;;-1:-1:-1;;3847:76:7;;4012:33:::2;;;4028:17;4012:33;4004:104;;;::::0;-1:-1:-1;;;4004:104:7;;7589:2:8;4004:104:7::2;::::0;::::2;7571:21:8::0;7628:2;7608:18;;;7601:30;7667:34;7647:18;;;7640:62;7738:28;7718:18;;;7711:56;7784:19;;4004:104:7::2;7387:422:8::0;4004:104:7::2;4118:11;4143:12;4139:121;;;4171:29;::::0;::::2;:36:::0;;-1:-1:-1;;4171:36:7::2;4203:4;4171:36;::::0;;4231:18:::2;::::0;::::2;::::0;4221:28:::2;::::0;;::::2;:::i;:::-;;;4139:121;4286:30;::::0;;::::2;::::0;::::2;::::0;;;;;;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;;;;;;;;::::2;::::0;::::2;::::0;;;;;::::2;::::0;::::2;::::0;::::2;;;;::::0;;;;4269:14:::2;::::0;4286:30:::2;::::0;:20:::2;:30::i;:::-;4269:47;;4348:9;4326:8;:18;;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;4367:19:7::2;::::0;-1:-1:-1;4377:9:7;4367:19;::::2;:::i;:::-;;;4414:6;4396:14;;:24;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;4430:6:7::2;::::0;:41:::2;::::0;-1:-1:-1;;;;;4430:6:7::2;719:10:6::0;4464:6:7;4430:19:::2;:41::i;:::-;4486:31;719:10:6::0;4486:31:7::2;::::0;;-1:-1:-1;;;;;8006:55:8;;;7988:74;;8093:2;8078:18;;8071:34;;;7961:18;4486:31:7::2;;;;;;;3635:889;;;;;;1224:258:::1;2292:1:1;;2303:20:::0;1716:1;2809:22;;2629:209;2303:20;3530:994:7;:::o;5004:194::-;5121:15;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5121:15:7;-1:-1:-1;;;;;1259:13:7;;1234:22;1259:13;;;:6;:13;;;;;:31;5092:5;;5099:11;;1308:21;1300:76;;;;-1:-1:-1;;;1300:76:7;;6362:2:8;1300:76:7;;;6344:21:8;6401:2;6381:18;;;6374:30;6440:34;6420:18;;;6413:62;-1:-1:-1;;;6491:18:8;;;6484:40;6541:19;;1300:76:7;6160:406:8;1300:76:7;1408:17;1394:11;:31;1386:78;;;;-1:-1:-1;;;1386:78:7;;6773:2:8;1386:78:7;;;6755:21:8;6812:2;6792:18;;;6785:30;6851:34;6831:18;;;6824:62;-1:-1:-1;;;6902:18:8;;;6895:32;6944:19;;1386:78:7;6571:398:8;1386:78:7;-1:-1:-1;;;;;5155:13:7;::::1;;::::0;;;:6:::1;:13;::::0;;;;;;;:36;;;:23:::1;::::0;;::::1;:36:::0;;;;;;5148:43;;::::1;::::0;::::1;::::0;;;;;;;;::::1;::::0;;;::::1;::::0;;;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;::::1;;::::0;::::1;;;;::::0;;;;;-1:-1:-1;1224:258:7;5004:194;;;;;;:::o;1831:101:0:-;1094:13;:11;:13::i;:::-;1895:30:::1;1922:1;1895:18;:30::i;:::-;1831:101::o:0;2958:527:7:-;1094:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;3039:30:7;::::1;3031:92;;;::::0;-1:-1:-1;;;3031:92:7;;8318:2:8;3031:92:7::1;::::0;::::1;8300:21:8::0;8357:2;8337:18;;;8330:30;8396:34;8376:18;;;8369:62;8467:19;8447:18;;;8440:47;8504:19;;3031:92:7::1;8116:413:8::0;3031:92:7::1;6080:16:::0;;:20;3133:83:::1;;;::::0;-1:-1:-1;;;3133:83:7;;8736:2:8;3133:83:7::1;::::0;::::1;8718:21:8::0;8775:2;8755:18;;;8748:30;8814:34;8794:18;;;8787:62;8885:19;8865:18;;;8858:47;8922:19;;3133:83:7::1;8534:413:8::0;3133:83:7::1;3248:1;3234:11;;:15;3226:70;;;::::0;-1:-1:-1;;;3226:70:7;;9154:2:8;3226:70:7::1;::::0;::::1;9136:21:8::0;9193:2;9173:18;;;9166:30;9232:34;9212:18;;;9205:62;9303:12;9283:18;;;9276:40;9333:19;;3226:70:7::1;8952:406:8::0;3226:70:7::1;3306:6;:16:::0;;-1:-1:-1;;3306:16:7::1;-1:-1:-1::0;;;;;3306:16:7;::::1;;::::0;;3351:15:::1;3332:16;:34:::0;3376:65:::1;719:10:6::0;3429:11:7::1;::::0;3376:6:::1;::::0;-1:-1:-1;;;;;3376:6:7::1;::::0;:65;3422:4:::1;::::0;3376:23:::1;:65::i;:::-;3456:22;::::0;::::1;::::0;;;::::1;2958:527:::0;:::o;2081:198:0:-;1094:13;:11;:13::i;:::-;-1:-1:-1;;;;;2169:22:0;::::1;2161:73;;;::::0;-1:-1:-1;;;2161:73:0;;9565:2:8;2161:73:0::1;::::0;::::1;9547:21:8::0;9604:2;9584:18;;;9577:30;9643:34;9623:18;;;9616:62;9714:8;9694:18;;;9687:36;9740:19;;2161:73:0::1;9363:402:8::0;2161:73:0::1;2244:28;2263:8;2244:18;:28::i;1359:130::-:0;1247:7;1273:6;-1:-1:-1;;;;;1273:6:0;719:10:6;1422:23:0;1414:68;;;;-1:-1:-1;;;1414:68:0;;9972:2:8;1414:68:0;;;9954:21:8;;;9991:18;;;9984:30;10050:34;10030:18;;;10023:62;10102:18;;1414:68:0;9770:356:8;2336:287:1;1759:1;2468:7;;:19;;2460:63;;;;-1:-1:-1;;;2460:63:1;;10333:2:8;2460:63:1;;;10315:21:8;10372:2;10352:18;;;10345:30;10411:33;10391:18;;;10384:61;10462:18;;2460:63:1;10131:355:8;2460:63:1;1759:1;2598:7;:18;2336:287::o;5410:459:7:-;5490:11;5513:12;5547:9;:16;;;5528;;:35;;;;:::i;:::-;5513:50;;5596:7;5577:15;:26;5573:290;;5647:19;;;;5628:16;;:38;;5647:19;5628:38;:::i;:::-;5619:47;;5573:290;;;5697:19;5737:16;;5719:15;:34;;;;:::i;:::-;5697:56;;5833:9;:19;;;5813:9;:16;;;5796:14;5777:9;:16;;;:33;;;;:::i;:::-;:52;;;;:::i;:::-;5776:76;;;;:::i;:::-;5767:85;;5683:180;5573:290;5503:366;5410:459;;;:::o;763:205:4:-;902:58;;-1:-1:-1;;;;;8006:55:8;;902:58:4;;;7988:74:8;8078:18;;;8071:34;;;875:86:4;;895:5;;925:23;;7961:18:8;;902:58:4;;;;-1:-1:-1;;902:58:4;;;;;;;;;;;;;;;;;;;;;;;;;;;875:19;:86::i;:::-;763:205;;;:::o;2433:187:0:-;2506:16;2525:6;;-1:-1:-1;;;;;2541:17:0;;;-1:-1:-1;;2541:17:0;;;;;;2573:40;;2525:6;;;;;;;2573:40;;2506:16;2573:40;2496:124;2433:187;:::o;974:241:4:-;1139:68;;-1:-1:-1;;;;;10772:15:8;;;1139:68:4;;;10754:34:8;10824:15;;10804:18;;;10797:43;10856:18;;;10849:34;;;1112:96:4;;1132:5;;1162:27;;10666:18:8;;1139:68:4;10491:398:8;1112:96:4;974:241;;;;:::o;3747:706::-;4166:23;4192:69;4220:4;4192:69;;;;;;;;;;;;;;;;;4200:5;-1:-1:-1;;;;;4192:27:4;;;:69;;;;;:::i;:::-;4275:17;;4166:95;;-1:-1:-1;4275:21:4;4271:176;;4370:10;4359:30;;;;;;;;;;;;:::i;:::-;4351:85;;;;-1:-1:-1;;;4351:85:4;;11378:2:8;4351:85:4;;;11360:21:8;11417:2;11397:18;;;11390:30;11456:34;11436:18;;;11429:62;11527:12;11507:18;;;11500:40;11557:19;;4351:85:4;11176:406:8;3873:223:5;4006:12;4037:52;4059:6;4067:4;4073:1;4076:12;4037:21;:52::i;:::-;4030:59;3873:223;-1:-1:-1;;;;3873:223:5:o;4960:446::-;5125:12;5182:5;5157:21;:30;;5149:81;;;;-1:-1:-1;;;5149:81:5;;11789:2:8;5149:81:5;;;11771:21:8;11828:2;11808:18;;;11801:30;11867:34;11847:18;;;11840:62;11938:8;11918:18;;;11911:36;11964:19;;5149:81:5;11587:402:8;5149:81:5;5241:12;5255:23;5282:6;-1:-1:-1;;;;;5282:11:5;5301:5;5308:4;5282:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5240:73;;;;5330:69;5357:6;5365:7;5374:10;5386:12;5330:26;:69::i;:::-;5323:76;4960:446;-1:-1:-1;;;;;;;4960:446:5:o;7466:628::-;7646:12;7674:7;7670:418;;;7701:17;;7697:286;;-1:-1:-1;;;;;1465:19:5;;;7908:60;;;;-1:-1:-1;;;7908:60:5;;12738:2:8;7908:60:5;;;12720:21:8;12777:2;12757:18;;;12750:30;12816:31;12796:18;;;12789:59;12865:18;;7908:60:5;12536:353:8;7908:60:5;-1:-1:-1;8003:10:5;7996:17;;7670:418;8044:33;8052:10;8064:12;8775:17;;:21;8771:379;;9003:10;8997:17;9059:15;9046:10;9042:2;9038:19;9031:44;8771:379;9126:12;9119:20;;-1:-1:-1;;;9119:20:5;;;;;;;;:::i;196:367:8:-;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:8;;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:910::-;708:6;716;724;732;740;748;801:3;789:9;780:7;776:23;772:33;769:53;;;818:1;815;808:12;769:53;858:9;845:23;887:18;928:2;920:6;917:14;914:34;;;944:1;941;934:12;914:34;983:70;1045:7;1036:6;1025:9;1021:22;983:70;:::i;:::-;1072:8;;-1:-1:-1;957:96:8;-1:-1:-1;1160:2:8;1145:18;;1132:32;;-1:-1:-1;1176:16:8;;;1173:36;;;1205:1;1202;1195:12;1173:36;;1244:72;1308:7;1297:8;1286:9;1282:24;1244:72;:::i;:::-;568:910;;;;-1:-1:-1;1335:8:8;1417:2;1402:18;;1389:32;;1468:2;1453:18;;;1440:32;;-1:-1:-1;568:910:8;-1:-1:-1;;;;568:910:8:o;1483:180::-;1542:6;1595:2;1583:9;1574:7;1570:23;1566:32;1563:52;;;1611:1;1608;1601:12;1563:52;-1:-1:-1;1634:23:8;;1483:180;-1:-1:-1;1483:180:8:o;1913:154::-;-1:-1:-1;;;;;1992:5:8;1988:54;1981:5;1978:65;1968:93;;2057:1;2054;2047:12;2072:315;2140:6;2148;2201:2;2189:9;2180:7;2176:23;2172:32;2169:52;;;2217:1;2214;2207:12;2169:52;2256:9;2243:23;2275:31;2300:5;2275:31;:::i;:::-;2325:5;2377:2;2362:18;;;;2349:32;;-1:-1:-1;;;2072:315:8:o;3131:247::-;3190:6;3243:2;3231:9;3222:7;3218:23;3214:32;3211:52;;;3259:1;3256;3249:12;3211:52;3298:9;3285:23;3317:31;3342:5;3317:31;:::i;:::-;3367:5;3131:247;-1:-1:-1;;;3131:247:8:o;4927:184::-;-1:-1:-1;;;4976:1:8;4969:88;5076:4;5073:1;5066:15;5100:4;5097:1;5090:15;5116:184;-1:-1:-1;;;5165:1:8;5158:88;5265:4;5262:1;5255:15;5289:4;5286:1;5279:15;5305:128;5345:3;5376:1;5372:6;5369:1;5366:13;5363:39;;;5382:18;;:::i;:::-;-1:-1:-1;5418:9:8;;5305:128::o;5438:168::-;5478:7;5544:1;5540;5536:6;5532:14;5529:1;5526:21;5521:1;5514:9;5507:17;5503:45;5500:71;;;5551:18;;:::i;:::-;-1:-1:-1;5591:9:8;;5438:168::o;5611:274::-;5651:1;5677;5667:189;;-1:-1:-1;;;5709:1:8;5702:88;5813:4;5810:1;5803:15;5841:4;5838:1;5831:15;5667:189;-1:-1:-1;5870:9:8;;5611:274::o;5890:125::-;5930:4;5958:1;5955;5952:8;5949:34;;;5963:18;;:::i;:::-;-1:-1:-1;6000:9:8;;5890:125::o;6020:135::-;6059:3;-1:-1:-1;;6080:17:8;;6077:43;;;6100:18;;:::i;:::-;-1:-1:-1;6147:1:8;6136:13;;6020:135::o;10894:277::-;10961:6;11014:2;11002:9;10993:7;10989:23;10985:32;10982:52;;;11030:1;11027;11020:12;10982:52;11062:9;11056:16;11115:5;11108:13;11101:21;11094:5;11091:32;11081:60;;11137:1;11134;11127:12;11994:258;12066:1;12076:113;12090:6;12087:1;12084:13;12076:113;;;12166:11;;;12160:18;12147:11;;;12140:39;12112:2;12105:10;12076:113;;;12207:6;12204:1;12201:13;12198:48;;;-1:-1:-1;;12242:1:8;12224:16;;12217:27;11994:258::o;12257:274::-;12386:3;12424:6;12418:13;12440:53;12486:6;12481:3;12474:4;12466:6;12462:17;12440:53;:::i;:::-;12509:16;;;;;12257:274;-1:-1:-1;;12257:274:8:o;12894:383::-;13043:2;13032:9;13025:21;13006:4;13075:6;13069:13;13118:6;13113:2;13102:9;13098:18;13091:34;13134:66;13193:6;13188:2;13177:9;13173:18;13168:2;13160:6;13156:15;13134:66;:::i;:::-;13261:2;13240:15;-1:-1:-1;;13236:29:8;13221:45;;;;13268:2;13217:54;;12894:383;-1:-1:-1;;12894:383:8:o

ipfs://5166aeb624c5b7c659a231623330fa73b3058f9eb02a2063e6262b0dbf1acf8b