Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library Address
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(bool succes ...
•    - function _revert(bytes memory returnd ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
•  contract Vesting *
•    - function init(address[] memory who, u ...
•    - function claim()
•    - function setOwner(address _owner)
•    - function withdraw(uint256 amount, add ...
•    - function withdrawAll(address _token)
•    - function rescue(address target, uint2 ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at SonicScan.org on 2025-01-11
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20 ^0.8.7;

// lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

/**
 * @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.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
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].
     *
     * CAUTION: See Security Considerations above.
     */
    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);
}

// lib/openzeppelin-contracts/contracts/utils/Address.sol

// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) 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 FailedInnerCall();
        }
    }
}

// lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

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

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @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);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// src/tokens/vesting.sol

contract Vesting  {

    
    using SafeERC20 for IERC20;

    struct User {
        address to;
        uint256 totalAmount;
        uint256 linearTokenPerSeconds;
        uint256 timestamp;
    }

    address public owner;
    address public token;
    address[] public usersList;
    
    uint256 public LINEAR = 2 * 86400 * 365;
    uint256 public NOT_CLAIMABLE_TIME = 86400 * 7;
    uint256 public PRECISION = 1e6;
    uint256 public startTimestamp;

    mapping(address => User) public users;
    mapping(address => bool) public isUser;

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    constructor() {
        owner = msg.sender;
        token = address(0xd1DA314f7db27DbE3c61aC172bE13d86e67688B7);
    }

    bool initialized = false;

    // init distribution
    function init(address[] memory who, uint[] memory amounts) external onlyOwner {
        require(!initialized, "already initialized");
        initialized = true;
        startTimestamp = block.timestamp;

        require(who.length == amounts.length);
        uint256 i = 0;
        uint256 len = who.length;

        address wallet;
        uint amount;

        for(i; i < len; i++){
            wallet = who[i];
            amount = amounts[i];

            require(wallet != address(0));
            require(isUser[wallet] == false);
            require(amount > 0);

            users[wallet] = User({
                to:             wallet,
                totalAmount:    amount,
                linearTokenPerSeconds: amount * PRECISION / LINEAR,
                timestamp:      block.timestamp
            });

            isUser[wallet] = true;
            usersList.push(wallet);  
        }
    }

    function claim() external returns(uint) {
        require(isUser[msg.sender], 'not allowed');

        User memory _user = users[msg.sender];
        uint256 _timestamp = _user.timestamp;
        require(block.timestamp >= startTimestamp + NOT_CLAIMABLE_TIME, 'claim later');
        
        uint256 dt = block.timestamp - _timestamp;
        if (block.timestamp >= startTimestamp + LINEAR) {
            dt = startTimestamp + LINEAR - _timestamp;
        }
        require(dt > 0);
        
        uint256 toDistribute = _user.linearTokenPerSeconds * dt / PRECISION;

        _user.timestamp = block.timestamp;
        users[msg.sender] = _user;
               
        IERC20(token).safeTransfer(msg.sender, toDistribute);
        return toDistribute;
    }
    
    function setOwner(address _owner) external onlyOwner {
        require(_owner != address(0));
        owner = _owner;
    }

    function withdraw(uint256 amount, address _token, address _to) external onlyOwner {
        IERC20(_token).safeTransfer(_to, amount);
    }

    function withdrawAll(address _token) external onlyOwner {
        IERC20(_token).safeTransfer(owner, IERC20(token).balanceOf(address(this)));
    }

    function rescue(address target, uint256 value, bytes calldata data) external onlyOwner {
        (bool success, ) = target.call{value: value}(data);
        require(success, "Rescue: Call failed");
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"LINEAR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NOT_CLAIMABLE_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"who","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isUser","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"rescue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"users","outputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"totalAmount","type":"uint256"},{"internalType":"uint256","name":"linearTokenPerSeconds","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"usersList","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

19050:3234:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21635:126;;;;;;:::i;:::-;;:::i;:::-;;19896:938;;;;;;:::i;:::-;;:::i;19575:38::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3107:14:1;;3100:22;3082:41;;3070:2;3055:18;19575:38:0;;;;;;;;20842:781;;;:::i;:::-;;;3280:25:1;;;3268:2;3253:18;20842:781:0;3134:177:1;19319:26:0;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;3711:55:1;;;3693:74;;3681:2;3666:18;19319:26:0;3547:226:1;22075:206:0;;;;;;:::i;:::-;;:::i;19265:20::-;;;;;-1:-1:-1;;;;;19265:20:0;;;19531:37;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19531:37:0;;;;;;;;;;;;-1:-1:-1;;;;;4806:55:1;;;4788:74;;4893:2;4878:18;;4871:34;;;;4921:18;;;4914:34;4979:2;4964:18;;4957:34;4775:3;4760:19;19531:37:0;4557:440:1;19456:30:0;;;;;;21769:141;;;;;;:::i;:::-;;:::i;19358:39::-;;;;;;19404:45;;;;;;19493:29;;;;;;21918:149;;;;;;:::i;:::-;;:::i;19292:20::-;;;;;-1:-1:-1;;;;;19292:20:0;;;21635:126;19674:5;;-1:-1:-1;;;;;19674:5:0;19660:10;:19;19652:28;;;;;;-1:-1:-1;;;;;21707:20:0;::::1;21699:29;;;;;;21739:5;:14:::0;;-1:-1:-1;;21739:14:0::1;-1:-1:-1::0;;;;;21739:14:0;;;::::1;::::0;;;::::1;::::0;;21635:126::o;19896:938::-;19674:5;;-1:-1:-1;;;;;19674:5:0;19660:10;:19;19652:28;;;;;;19994:11:::1;::::0;::::1;;19993:12;19985:44;;;::::0;-1:-1:-1;;;19985:44:0;;5583:2:1;19985:44:0::1;::::0;::::1;5565:21:1::0;5622:2;5602:18;;;5595:30;5661:21;5641:18;;;5634:49;5700:18;;19985:44:0::1;;;;;;;;;20040:11;:18:::0;;-1:-1:-1;;20040:18:0::1;20054:4;20040:18;::::0;;20086:15:::1;20069:14;:32:::0;20136:14;;20122:10;;:28:::1;20114:37;;;;;;20200:10:::0;;20162:9:::1;::::0;;;20272:555:::1;20283:3;20279:1;:7;20272:555;;;20316:3;20320:1;20316:6;;;;;;;;:::i;:::-;;;;;;;20307:15;;20346:7;20354:1;20346:10;;;;;;;;:::i;:::-;;;;;;;20337:19;;20399:1;-1:-1:-1::0;;;;;20381:20:0::1;:6;-1:-1:-1::0;;;;;20381:20:0::1;::::0;20373:29:::1;;;;;;-1:-1:-1::0;;;;;20425:14:0;::::1;;::::0;;;:6:::1;:14;::::0;;;;;::::1;;:23;20417:32;;;;;;20481:1;20472:6;:10;20464:19;;;;;;20516:222;;;;;;;;20556:6;-1:-1:-1::0;;;;;20516:222:0::1;;;;;20597:6;20516:222;;;;20666:6;;20654:9;;20645:6;:18;;;;:::i;:::-;:27;;;;:::i;:::-;20516:222:::0;;20707:15:::1;20516:222;::::0;;::::1;::::0;-1:-1:-1;;;;;20500:13:0;;::::1;-1:-1:-1::0;20500:13:0;;;:5:::1;:13:::0;;;;;;:238;;;;;::::1;-1:-1:-1::0;;20500:238:0;;::::1;;::::0;;;;::::1;::::0;;;;::::1;::::0;;;;;;::::1;::::0;::::1;::::0;;::::1;::::0;;;;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;;;20755:6:::1;:14:::0;;;;;:21;;-1:-1:-1;;20755:21:0::1;::::0;::::1;::::0;;20791:22;;;;::::1;::::0;;;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;::::0;;;20288:3;;;::::1;::::0;20272:555:::1;;;19974:860;;;;19896:938:::0;;:::o;20842:781::-;20908:10;20876:4;20901:18;;;:6;:18;;;;;;;;20893:42;;;;-1:-1:-1;;;20893:42:0;;6761:2:1;20893:42:0;;;6743:21:1;6800:2;6780:18;;;6773:30;6839:13;6819:18;;;6812:41;6870:18;;20893:42:0;6559:335:1;20893:42:0;20974:10;20948:17;20968;;;:5;:17;;;;;;;;;20948:37;;;;;;;;;-1:-1:-1;;;;;20948:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21087:18;;21070:14;;:35;;21087:18;21070:35;:::i;:::-;21051:15;:54;;21043:78;;;;-1:-1:-1;;;21043:78:0;;7231:2:1;21043:78:0;;;7213:21:1;7270:2;7250:18;;;7243:30;7309:13;7289:18;;;7282:41;7340:18;;21043:78:0;7029:335:1;21043:78:0;21142:10;21155:28;21173:10;21155:15;:28;:::i;:::-;21142:41;;21234:6;;21217:14;;:23;;;;:::i;:::-;21198:15;:42;21194:116;;21288:10;21279:6;;21262:14;;:23;;;;:::i;:::-;:36;;;;:::i;:::-;21257:41;;21194:116;21333:1;21328:2;:6;21320:15;;;;;;21356:20;21414:9;;21409:2;21379:5;:27;;;:32;;;;:::i;:::-;:44;;;;:::i;:::-;21454:15;21436;;;:33;;;21486:10;21480:17;;;;:5;:17;;;;;;;;;:25;;;;-1:-1:-1;;21480:25:0;-1:-1:-1;;;;;21480:25:0;;;;;;;;;;-1:-1:-1;21480:25:0;;;;;;;;;;;;;;;;;;;;;;;;;21540:5;21356:67;;-1:-1:-1;21533:52:0;;21540:5;;;;21356:67;21533:26;:52::i;:::-;21603:12;20842:781;-1:-1:-1;;;;20842:781:0:o;19319:26::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19319:26:0;;-1:-1:-1;19319:26:0;:::o;22075:206::-;19674:5;;-1:-1:-1;;;;;19674:5:0;19660:10;:19;19652:28;;;;;;22174:12:::1;22192:6;-1:-1:-1::0;;;;;22192:11:0::1;22211:5;22218:4;;22192:31;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22173:50;;;22242:7;22234:39;;;::::0;-1:-1:-1;;;22234:39:0;;7980:2:1;22234:39:0::1;::::0;::::1;7962:21:1::0;8019:2;7999:18;;;7992:30;8058:21;8038:18;;;8031:49;8097:18;;22234:39:0::1;7778:343:1::0;22234:39:0::1;22162:119;22075:206:::0;;;;:::o;21769:141::-;19674:5;;-1:-1:-1;;;;;19674:5:0;19660:10;:19;19652:28;;;;;;21862:40:::1;-1:-1:-1::0;;;;;21862:27:0;::::1;21890:3:::0;21895:6;21862:27:::1;:40::i;:::-;21769:141:::0;;;:::o;21918:149::-;19674:5;;-1:-1:-1;;;;;19674:5:0;19660:10;:19;19652:28;;;;;;22013:5:::1;::::0;;22027;22020:38:::1;::::0;;;;22052:4:::1;22020:38;::::0;::::1;3693:74:1::0;21985::0::1;::::0;-1:-1:-1;;;;;22013:5:0;;::::1;::::0;22027::::1;::::0;22020:23:::1;::::0;3666:18:1;;22020:38:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;21985:27:0;::::1;::::0;:74;:27:::1;:74::i;:::-;21918:149:::0;:::o;14469:162::-;14579:43;;;-1:-1:-1;;;;;8507:55:1;;;14579:43:0;;;8489:74:1;8579:18;;;;8572:34;;;14579:43:0;;;;;;;;;;8462:18:1;;;;14579:43:0;;;;;;;;;;;;;;14552:71;;14572:5;;14579:43;-1:-1:-1;;17730:33:0;;14594:14;;14579:43;17730:27;:33::i;:::-;17704:59;;17778:10;:17;17799:1;17778:22;;:57;;;;;17816:10;17805:30;;;;;;;;;;;;:::i;:::-;17804:31;17778:57;17774:137;;;17859:40;;;;;-1:-1:-1;;;;;3711:55:1;;17859:40:0;;;3693:74:1;3666:18;;17859:40:0;3547:226:1;9624:153:0;9699:12;9731:38;9753:6;9761:4;9767:1;9731:21;:38::i;:::-;9724:45;;9624:153;;;;;:::o;10112:398::-;10211:12;10264:5;10240:21;:29;10236:110;;;10293:41;;;;;10328:4;10293:41;;;3693:74:1;3666:18;;10293:41:0;3547:226:1;10236:110:0;10357:12;10371:23;10398:6;-1:-1:-1;;;;;10398:11:0;10417:5;10424:4;10398:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10356:73;;;;10447:55;10474:6;10482:7;10491:10;10447:26;:55::i;:::-;10440:62;;;;10112:398;;;;;;:::o;11588:597::-;11736:12;11766:7;11761:417;;11790:19;11798:10;11790:7;:19::i;:::-;11761:417;;;12018:17;;:22;:49;;;;-1:-1:-1;;;;;;12044:18:0;;;:23;12018:49;12014:121;;;12095:24;;;;;-1:-1:-1;;;;;3711:55:1;;12095:24:0;;;3693:74:1;3666:18;;12095:24:0;3547:226:1;12014:121:0;-1:-1:-1;12156:10:0;12149:17;;12738:528;12871:17;;:21;12867:392;;13103:10;13097:17;13160:15;13147:10;13143:2;13139:19;13132:44;12867:392;13230:17;;;;;;;;;;;;;;14:196:1;82:20;;-1:-1:-1;;;;;131:54:1;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:186::-;274:6;327:2;315:9;306:7;302:23;298:32;295:52;;;343:1;340;333:12;295:52;366:29;385:9;366:29;:::i;406:184::-;-1:-1:-1;;;455:1:1;448:88;555:4;552:1;545:15;579:4;576:1;569:15;595:275;666:2;660:9;731:2;712:13;;-1:-1:-1;;708:27:1;696:40;;766:18;751:34;;787:22;;;748:62;745:88;;;813:18;;:::i;:::-;849:2;842:22;595:275;;-1:-1:-1;595:275:1:o;875:183::-;935:4;968:18;960:6;957:30;954:56;;;990:18;;:::i;:::-;-1:-1:-1;1035:1:1;1031:14;1047:4;1027:25;;875:183::o;1063:723::-;1117:5;1170:3;1163:4;1155:6;1151:17;1147:27;1137:55;;1188:1;1185;1178:12;1137:55;1228:6;1215:20;1255:64;1271:47;1311:6;1271:47;:::i;:::-;1255:64;:::i;:::-;1343:3;1367:6;1362:3;1355:19;1399:4;1394:3;1390:14;1383:21;;1460:4;1450:6;1447:1;1443:14;1435:6;1431:27;1427:38;1413:52;;1488:3;1480:6;1477:15;1474:35;;;1505:1;1502;1495:12;1474:35;1541:4;1533:6;1529:17;1555:200;1571:6;1566:3;1563:15;1555:200;;;1663:17;;1693:18;;1740:4;1731:14;;;;1588;1555:200;;;-1:-1:-1;1773:7:1;1063:723;-1:-1:-1;;;;;1063:723:1:o;1791:1146::-;1909:6;1917;1970:2;1958:9;1949:7;1945:23;1941:32;1938:52;;;1986:1;1983;1976:12;1938:52;2026:9;2013:23;2059:18;2051:6;2048:30;2045:50;;;2091:1;2088;2081:12;2045:50;2114:22;;2167:4;2159:13;;2155:27;-1:-1:-1;2145:55:1;;2196:1;2193;2186:12;2145:55;2236:2;2223:16;2259:64;2275:47;2315:6;2275:47;:::i;2259:64::-;2345:3;2369:6;2364:3;2357:19;2401:4;2396:3;2392:14;2385:21;;2458:4;2448:6;2445:1;2441:14;2437:2;2433:23;2429:34;2415:48;;2486:7;2478:6;2475:19;2472:39;;;2507:1;2504;2497:12;2472:39;2539:4;2535:2;2531:13;2520:24;;2553:152;2569:6;2564:3;2561:15;2553:152;;;2637:23;2656:3;2637:23;:::i;:::-;2625:36;;2690:4;2586:14;;;;2681;;;;2553:152;;;2724:5;-1:-1:-1;;;;2782:4:1;2767:20;;2754:34;2813:18;2800:32;;2797:52;;;2845:1;2842;2835:12;2797:52;2868:63;2923:7;2912:8;2901:9;2897:24;2868:63;:::i;:::-;2858:73;;;1791:1146;;;;;:::o;3316:226::-;3375:6;3428:2;3416:9;3407:7;3403:23;3399:32;3396:52;;;3444:1;3441;3434:12;3396:52;-1:-1:-1;3489:23:1;;3316:226;-1:-1:-1;3316:226:1:o;3778:774::-;3866:6;3874;3882;3890;3943:2;3931:9;3922:7;3918:23;3914:32;3911:52;;;3959:1;3956;3949:12;3911:52;3982:29;4001:9;3982:29;:::i;:::-;3972:39;-1:-1:-1;4080:2:1;4065:18;;4052:32;;-1:-1:-1;4159:2:1;4144:18;;4131:32;4186:18;4175:30;;4172:50;;;4218:1;4215;4208:12;4172:50;4241:22;;4294:4;4286:13;;4282:27;-1:-1:-1;4272:55:1;;4323:1;4320;4313:12;4272:55;4363:2;4350:16;4389:18;4381:6;4378:30;4375:50;;;4421:1;4418;4411:12;4375:50;4466:7;4461:2;4452:6;4448:2;4444:15;4440:24;4437:37;4434:57;;;4487:1;4484;4477:12;4434:57;3778:774;;;;-1:-1:-1;4518:2:1;4510:11;;-1:-1:-1;;;3778:774:1:o;5002:374::-;5079:6;5087;5095;5148:2;5136:9;5127:7;5123:23;5119:32;5116:52;;;5164:1;5161;5154:12;5116:52;5209:23;;;-1:-1:-1;5275:38:1;5309:2;5294:18;;5275:38;:::i;:::-;5265:48;;5332:38;5366:2;5355:9;5351:18;5332:38;:::i;:::-;5322:48;;5002:374;;;;;:::o;5729:184::-;-1:-1:-1;;;5778:1:1;5771:88;5878:4;5875:1;5868:15;5902:4;5899:1;5892:15;5918:184;-1:-1:-1;;;5967:1:1;5960:88;6067:4;6064:1;6057:15;6091:4;6088:1;6081:15;6107:168;6180:9;;;6211;;6228:15;;;6222:22;;6208:37;6198:71;;6249:18;;:::i;6280:274::-;6320:1;6346;6336:189;;-1:-1:-1;;;6378:1:1;6371:88;6482:4;6479:1;6472:15;6510:4;6507:1;6500:15;6336:189;-1:-1:-1;6539:9:1;;6280:274::o;6899:125::-;6964:9;;;6985:10;;;6982:36;;;6998:18;;:::i;7369:128::-;7436:9;;;7457:11;;;7454:37;;;7471:18;;:::i;7502:271::-;7685:6;7677;7672:3;7659:33;7641:3;7711:16;;7736:13;;;7711:16;7502:271;-1:-1:-1;7502:271:1:o;8126:184::-;8196:6;8249:2;8237:9;8228:7;8224:23;8220:32;8217:52;;;8265:1;8262;8255:12;8217:52;-1:-1:-1;8288:16:1;;8126:184;-1:-1:-1;8126:184:1:o;8617:277::-;8684:6;8737:2;8725:9;8716:7;8712:23;8708:32;8705:52;;;8753:1;8750;8743:12;8705:52;8785:9;8779:16;8838:5;8831:13;8824:21;8817:5;8814:32;8804:60;;8860:1;8857;8850:12;8899:412;9028:3;9066:6;9060:13;9091:1;9101:129;9115:6;9112:1;9109:13;9101:129;;;9213:4;9197:14;;;9193:25;;9187:32;9174:11;;;9167:53;9130:12;9101:129;;;-1:-1:-1;9285:1:1;9249:16;;9274:13;;;-1:-1:-1;9249:16:1;8899:412;-1:-1:-1;8899:412:1:o

ipfs://7906c3d6d08fe8fe50af427654d995765e9c9c2387c14c9aef1fb387f05244bb