Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

/// @notice Sniping is bad for meme coins. This design prevents sniping
///         and offers fair initial distribution to everyone.
contract AntiSniping {
    address public addrARBToken;
    address public addrKUMAToken;
    uint256 public totalAllocation;
    uint256 public totalContribution;
    uint256 public totalNumberOfContributors;
    uint256 public capPerWallet; // e.g. max contribution per wallet: 100 ARB
    uint256 public contributionStartTime;
    uint256 public contributionPeriod;
    uint256 public vestingStartTime;
    uint256 public vestingPeriod;
    uint256 public totalClaim;
    address private _creator;

    mapping(address => uint256) public contributions;
    mapping(address => uint256) public claims;

    event Contribute(address indexed wallet, uint256 amount, uint256 totalPerWallet, uint256 totalContribution, uint256 totalContributors);
    event Claim(address indexed wallet, uint256 amount, uint256 totalPerWallet, uint256 totalClaim);

    constructor(address creator_, address kuma_, address arb_) {
        _creator = creator_;
        addrKUMAToken = kuma_;
        addrARBToken = arb_;
    }

    modifier onlyCreator() {
        require(msg.sender == _creator, "Not creator");
        _;
    }

    function contribute(uint256 amount) external {
        require((block.timestamp >= contributionStartTime) && (contributionStartTime > 0), "Not started yet");
        require(block.timestamp <= contributionStartTime + contributionPeriod, "Finished");
        require(amount > 0, "Zero amount");

        uint256 userContribution = contributions[msg.sender];
        require(userContribution < capPerWallet, "Cap reached");

        uint256 contributionAmount = amount > (capPerWallet - userContribution) ? (capPerWallet - userContribution) : amount;

        ERC20(addrARBToken).transferFrom(msg.sender, address(this), contributionAmount);
        contributions[msg.sender] += contributionAmount;
        totalContribution += contributionAmount;

        if (userContribution == 0) {
            totalNumberOfContributors++;
        }

        emit Contribute(msg.sender, contributionAmount, contributions[msg.sender], totalContribution, totalNumberOfContributors);
    }

    function claim() external {
        require((block.timestamp >= vestingStartTime) && (vestingStartTime > 0), "Vesting not started");

        uint256 vestedAmount = getVestedAmount(msg.sender);
        uint256 claimableAmount = vestedAmount - claims[msg.sender];
        require(claimableAmount > 0, "No token to claim");

        claims[msg.sender] += claimableAmount;
        totalClaim += claimableAmount;

        ERC20(addrKUMAToken).transfer(msg.sender, claimableAmount);

        emit Claim(msg.sender, claimableAmount, claims[msg.sender], totalClaim);
    }

    function initializeContribution(
        uint256 totalAllocation_,
        uint256 capPerWallet_,
        uint256 contributionStartTime_,
        uint256 contributionPeriod_
    ) external onlyCreator {
        require(contributionStartTime == 0, "Already initialized");
        require(totalAllocation_ > 0, "Zero allocation");

        ERC20(addrKUMAToken).transferFrom(_creator, address(this), totalAllocation_);
        totalAllocation = totalAllocation_;
        capPerWallet = capPerWallet_;
        contributionStartTime = contributionStartTime_;
        contributionPeriod = contributionPeriod_;
    }

    function initializeVesting(uint256 vestingStartTime_, uint256 vestingPeriod_) external onlyCreator {
        require(block.timestamp >= contributionStartTime + contributionPeriod, "Contribution not finished");
        require(vestingStartTime == 0, "Already initialized");

        vestingStartTime = vestingStartTime_;
        vestingPeriod = vestingPeriod_;
    }

    function withdrawARB() external {
        uint256 balance = ERC20(addrARBToken).balanceOf(address(this));
        ERC20(addrARBToken).transfer(_creator, balance);
    }

    /// @notice the price is in xxxx KUMA per ARB with 8 decimals
    function getInitialPrice() public view returns (uint256) {
        if ((totalAllocation == 0) || (totalContribution == 0)) {
            return 0;
        } else {
            return totalAllocation * 1e8 / totalContribution;
        }
    }

    function getVestedAmount(address wallet) public view returns (uint256) {
        uint256 totalAmount = (contributions[wallet] * totalAllocation) / totalContribution;

        if ((block.timestamp < vestingStartTime) || (vestingStartTime == 0) || (vestingPeriod == 0)) {
            return 0;
        } else if(block.timestamp > vestingStartTime + vestingPeriod) {
            return totalAmount;
        } else {
            uint256 elapsed = block.timestamp - vestingStartTime;
            return (totalAmount * elapsed) / vestingPeriod;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

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

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

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @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);
}

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

pragma solidity ^0.8.20;

/**
 * @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);
}

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

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../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;

    /**
     * @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;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @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();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

{
  "evmVersion": "paris",
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"creator_","type":"address"},{"internalType":"address","name":"kuma_","type":"address"},{"internalType":"address","name":"arb_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalPerWallet","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalClaim","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalPerWallet","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalContribution","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalContributors","type":"uint256"}],"name":"Contribute","type":"event"},{"inputs":[],"name":"addrARBToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"addrKUMAToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"capPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claims","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"contribute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contributionPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contributionStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"contributions","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getInitialPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"getVestedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"totalAllocation_","type":"uint256"},{"internalType":"uint256","name":"capPerWallet_","type":"uint256"},{"internalType":"uint256","name":"contributionStartTime_","type":"uint256"},{"internalType":"uint256","name":"contributionPeriod_","type":"uint256"}],"name":"initializeContribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"vestingStartTime_","type":"uint256"},{"internalType":"uint256","name":"vestingPeriod_","type":"uint256"}],"name":"initializeVesting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAllocation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalContribution","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalNumberOfContributors","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawARB","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000c5cd9c7b916a112b544d1434c85863397ac1ffa20000000000000000000000000de59c86c306b9fead9fb67e65551e2b6897c3f6000000000000000000000000912ce59144191c1204e64559fe8253a0e49e6548

-----Decoded View---------------
Arg [0] : creator_ (address): 0xc5cd9C7b916a112B544D1434C85863397ac1FFa2
Arg [1] : kuma_ (address): 0x0de59c86C306B9Fead9FB67e65551E2B6897c3F6
Arg [2] : arb_ (address): 0x912CE59144191C1204E64559FE8253a0e49E6548

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000c5cd9c7b916a112b544d1434c85863397ac1ffa2
Arg [1] : 0000000000000000000000000de59c86c306b9fead9fb67e65551e2b6897c3f6
Arg [2] : 000000000000000000000000912ce59144191c1204e64559fe8253a0e49e6548

253:4690:8:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;467:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4140:241;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;383:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;587:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;545:36;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;313:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;759:48;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2343:565;;;:::i;:::-;;697:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;280:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3900:168;;;:::i;:::-;;421:40;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;663:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;347:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;626:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1367:970;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;813:41;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4387:554;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2914:609;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3529:365;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;467:27;;;;:::o;4140:241::-;4188:7;4231:1;4212:15;;:20;4211:50;;;;4259:1;4238:17;;:22;4211:50;4207:168;;;4284:1;4277:8;;;;4207:168;4347:17;;4341:3;4323:15;;:21;;;;:::i;:::-;:41;;;;:::i;:::-;4316:48;;4140:241;;:::o;383:32::-;;;;:::o;587:33::-;;;;:::o;545:36::-;;;;:::o;313:28::-;;;;;;;;;;;;;:::o;759:48::-;;;;;;;;;;;;;;;;;:::o;2343:565::-;2407:16;;2388:15;:35;;2387:63;;;;;2448:1;2429:16;;:20;2387:63;2379:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;2485:20;2508:27;2524:10;2508:15;:27::i;:::-;2485:50;;2545:23;2586:6;:18;2593:10;2586:18;;;;;;;;;;;;;;;;2571:12;:33;;;;:::i;:::-;2545:59;;2640:1;2622:15;:19;2614:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;2696:15;2674:6;:18;2681:10;2674:18;;;;;;;;;;;;;;;;:37;;;;;;;:::i;:::-;;;;;;;;2735:15;2721:10;;:29;;;;;;;:::i;:::-;;;;;;;;2767:13;;;;;;;;;;;2761:29;;;2791:10;2803:15;2761:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2841:10;2835:66;;;2853:15;2870:6;:18;2877:10;2870:18;;;;;;;;;;;;;;;;2890:10;;2835:66;;;;;;;;:::i;:::-;;;;;;;;2369:539;;2343:565::o;697:25::-;;;;:::o;280:27::-;;;;;;;;;;;;:::o;3900:168::-;3942:15;3966:12;;;;;;;;;;;3960:29;;;3998:4;3960:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3942:62;;4020:12;;;;;;;;;;4014:28;;;4043:8;;;;;;;;;;;4053:7;4014:47;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3932:136;3900:168::o;421:40::-;;;;:::o;663:28::-;;;;:::o;347:30::-;;;;:::o;626:31::-;;;;:::o;1367:970::-;1450:21;;1431:15;:40;;1430:73;;;;;1501:1;1477:21;;:25;1430:73;1422:101;;;;;;;;;;;;:::i;:::-;;;;;;;;;1584:18;;1560:21;;:42;;;;:::i;:::-;1541:15;:61;;1533:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;1642:1;1633:6;:10;1625:34;;;;;;;;;;;;:::i;:::-;;;;;;;;;1670:24;1697:13;:25;1711:10;1697:25;;;;;;;;;;;;;;;;1670:52;;1759:12;;1740:16;:31;1732:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;1798:26;1852:16;1837:12;;:31;;;;:::i;:::-;1827:6;:42;:87;;1908:6;1827:87;;;1888:16;1873:12;;:31;;;;:::i;:::-;1827:87;1798:116;;1931:12;;;;;;;;;;1925:32;;;1958:10;1978:4;1985:18;1925:79;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2043:18;2014:13;:25;2028:10;2014:25;;;;;;;;;;;;;;;;:47;;;;;;;:::i;:::-;;;;;;;;2092:18;2071:17;;:39;;;;;;;:::i;:::-;;;;;;;;2145:1;2125:16;:21;2121:79;;2162:25;;:27;;;;;;;;;:::i;:::-;;;;;;2121:79;2226:10;2215:115;;;2238:18;2258:13;:25;2272:10;2258:25;;;;;;;;;;;;;;;;2285:17;;2304:25;;2215:115;;;;;;;;;:::i;:::-;;;;;;;;1412:925;;1367:970;:::o;813:41::-;;;;;;;;;;;;;;;;;:::o;4387:554::-;4449:7;4468:19;4534:17;;4515:15;;4491:13;:21;4505:6;4491:21;;;;;;;;;;;;;;;;:39;;;;:::i;:::-;4490:61;;;;:::i;:::-;4468:83;;4585:16;;4567:15;:34;4566:63;;;;4627:1;4607:16;;:21;4566:63;:87;;;;4651:1;4634:13;;:18;4566:87;4562:373;;;4676:1;4669:8;;;;;4562:373;4734:13;;4715:16;;:32;;;;:::i;:::-;4697:15;:50;4694:241;;;4770:11;4763:18;;;;;4694:241;4812:15;4848:16;;4830:15;:34;;;;:::i;:::-;4812:52;;4911:13;;4900:7;4886:11;:21;;;;:::i;:::-;4885:39;;;;:::i;:::-;4878:46;;;;4387:554;;;;:::o;2914:609::-;1319:8;;;;;;;;;;;1305:22;;:10;:22;;;1297:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;3158:1:::1;3133:21;;:26;3125:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;3220:1;3201:16;:20;3193:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;3258:13;;;;;;;;;;;3252:33;;;3286:8;;;;;;;;;;;3304:4;3311:16;3252:76;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3356:16;3338:15;:34;;;;3397:13;3382:12;:28;;;;3444:22;3420:21;:46;;;;3497:19;3476:18;:40;;;;2914:609:::0;;;;:::o;3529:365::-;1319:8;;;;;;;;;;;1305:22;;:10;:22;;;1297:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;3689:18:::1;;3665:21;;:42;;;;:::i;:::-;3646:15;:61;;3638:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;3775:1;3755:16;;:21;3747:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;3830:17;3811:16;:36;;;;3873:14;3857:13;:30;;;;3529:365:::0;;:::o;7:77:9:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:126::-;479:7;519:42;512:5;508:54;497:65;;442:126;;;:::o;574:96::-;611:7;640:24;658:5;640:24;:::i;:::-;629:35;;574:96;;;:::o;676:118::-;763:24;781:5;763:24;:::i;:::-;758:3;751:37;676:118;;:::o;800:222::-;893:4;931:2;920:9;916:18;908:26;;944:71;1012:1;1001:9;997:17;988:6;944:71;:::i;:::-;800:222;;;;:::o;1109:117::-;1218:1;1215;1208:12;1355:122;1428:24;1446:5;1428:24;:::i;:::-;1421:5;1418:35;1408:63;;1467:1;1464;1457:12;1408:63;1355:122;:::o;1483:139::-;1529:5;1567:6;1554:20;1545:29;;1583:33;1610:5;1583:33;:::i;:::-;1483:139;;;;:::o;1628:329::-;1687:6;1736:2;1724:9;1715:7;1711:23;1707:32;1704:119;;;1742:79;;:::i;:::-;1704:119;1862:1;1887:53;1932:7;1923:6;1912:9;1908:22;1887:53;:::i;:::-;1877:63;;1833:117;1628:329;;;;:::o;1963:122::-;2036:24;2054:5;2036:24;:::i;:::-;2029:5;2026:35;2016:63;;2075:1;2072;2065:12;2016:63;1963:122;:::o;2091:139::-;2137:5;2175:6;2162:20;2153:29;;2191:33;2218:5;2191:33;:::i;:::-;2091:139;;;;:::o;2236:329::-;2295:6;2344:2;2332:9;2323:7;2319:23;2315:32;2312:119;;;2350:79;;:::i;:::-;2312:119;2470:1;2495:53;2540:7;2531:6;2520:9;2516:22;2495:53;:::i;:::-;2485:63;;2441:117;2236:329;;;;:::o;2571:765::-;2657:6;2665;2673;2681;2730:3;2718:9;2709:7;2705:23;2701:33;2698:120;;;2737:79;;:::i;:::-;2698:120;2857:1;2882:53;2927:7;2918:6;2907:9;2903:22;2882:53;:::i;:::-;2872:63;;2828:117;2984:2;3010:53;3055:7;3046:6;3035:9;3031:22;3010:53;:::i;:::-;3000:63;;2955:118;3112:2;3138:53;3183:7;3174:6;3163:9;3159:22;3138:53;:::i;:::-;3128:63;;3083:118;3240:2;3266:53;3311:7;3302:6;3291:9;3287:22;3266:53;:::i;:::-;3256:63;;3211:118;2571:765;;;;;;;:::o;3342:474::-;3410:6;3418;3467:2;3455:9;3446:7;3442:23;3438:32;3435:119;;;3473:79;;:::i;:::-;3435:119;3593:1;3618:53;3663:7;3654:6;3643:9;3639:22;3618:53;:::i;:::-;3608:63;;3564:117;3720:2;3746:53;3791:7;3782:6;3771:9;3767:22;3746:53;:::i;:::-;3736:63;;3691:118;3342:474;;;;;:::o;3822:180::-;3870:77;3867:1;3860:88;3967:4;3964:1;3957:15;3991:4;3988:1;3981:15;4008:410;4048:7;4071:20;4089:1;4071:20;:::i;:::-;4066:25;;4105:20;4123:1;4105:20;:::i;:::-;4100:25;;4160:1;4157;4153:9;4182:30;4200:11;4182:30;:::i;:::-;4171:41;;4361:1;4352:7;4348:15;4345:1;4342:22;4322:1;4315:9;4295:83;4272:139;;4391:18;;:::i;:::-;4272:139;4056:362;4008:410;;;;:::o;4424:180::-;4472:77;4469:1;4462:88;4569:4;4566:1;4559:15;4593:4;4590:1;4583:15;4610:185;4650:1;4667:20;4685:1;4667:20;:::i;:::-;4662:25;;4701:20;4719:1;4701:20;:::i;:::-;4696:25;;4740:1;4730:35;;4745:18;;:::i;:::-;4730:35;4787:1;4784;4780:9;4775:14;;4610:185;;;;:::o;4801:169::-;4885:11;4919:6;4914:3;4907:19;4959:4;4954:3;4950:14;4935:29;;4801:169;;;;:::o;4976:::-;5116:21;5112:1;5104:6;5100:14;5093:45;4976:169;:::o;5151:366::-;5293:3;5314:67;5378:2;5373:3;5314:67;:::i;:::-;5307:74;;5390:93;5479:3;5390:93;:::i;:::-;5508:2;5503:3;5499:12;5492:19;;5151:366;;;:::o;5523:419::-;5689:4;5727:2;5716:9;5712:18;5704:26;;5776:9;5770:4;5766:20;5762:1;5751:9;5747:17;5740:47;5804:131;5930:4;5804:131;:::i;:::-;5796:139;;5523:419;;;:::o;5948:194::-;5988:4;6008:20;6026:1;6008:20;:::i;:::-;6003:25;;6042:20;6060:1;6042:20;:::i;:::-;6037:25;;6086:1;6083;6079:9;6071:17;;6110:1;6104:4;6101:11;6098:37;;;6115:18;;:::i;:::-;6098:37;5948:194;;;;:::o;6148:167::-;6288:19;6284:1;6276:6;6272:14;6265:43;6148:167;:::o;6321:366::-;6463:3;6484:67;6548:2;6543:3;6484:67;:::i;:::-;6477:74;;6560:93;6649:3;6560:93;:::i;:::-;6678:2;6673:3;6669:12;6662:19;;6321:366;;;:::o;6693:419::-;6859:4;6897:2;6886:9;6882:18;6874:26;;6946:9;6940:4;6936:20;6932:1;6921:9;6917:17;6910:47;6974:131;7100:4;6974:131;:::i;:::-;6966:139;;6693:419;;;:::o;7118:191::-;7158:3;7177:20;7195:1;7177:20;:::i;:::-;7172:25;;7211:20;7229:1;7211:20;:::i;:::-;7206:25;;7254:1;7251;7247:9;7240:16;;7275:3;7272:1;7269:10;7266:36;;;7282:18;;:::i;:::-;7266:36;7118:191;;;;:::o;7315:332::-;7436:4;7474:2;7463:9;7459:18;7451:26;;7487:71;7555:1;7544:9;7540:17;7531:6;7487:71;:::i;:::-;7568:72;7636:2;7625:9;7621:18;7612:6;7568:72;:::i;:::-;7315:332;;;;;:::o;7653:90::-;7687:7;7730:5;7723:13;7716:21;7705:32;;7653:90;;;:::o;7749:116::-;7819:21;7834:5;7819:21;:::i;:::-;7812:5;7809:32;7799:60;;7855:1;7852;7845:12;7799:60;7749:116;:::o;7871:137::-;7925:5;7956:6;7950:13;7941:22;;7972:30;7996:5;7972:30;:::i;:::-;7871:137;;;;:::o;8014:345::-;8081:6;8130:2;8118:9;8109:7;8105:23;8101:32;8098:119;;;8136:79;;:::i;:::-;8098:119;8256:1;8281:61;8334:7;8325:6;8314:9;8310:22;8281:61;:::i;:::-;8271:71;;8227:125;8014:345;;;;:::o;8365:442::-;8514:4;8552:2;8541:9;8537:18;8529:26;;8565:71;8633:1;8622:9;8618:17;8609:6;8565:71;:::i;:::-;8646:72;8714:2;8703:9;8699:18;8690:6;8646:72;:::i;:::-;8728;8796:2;8785:9;8781:18;8772:6;8728:72;:::i;:::-;8365:442;;;;;;:::o;8813:143::-;8870:5;8901:6;8895:13;8886:22;;8917:33;8944:5;8917:33;:::i;:::-;8813:143;;;;:::o;8962:351::-;9032:6;9081:2;9069:9;9060:7;9056:23;9052:32;9049:119;;;9087:79;;:::i;:::-;9049:119;9207:1;9232:64;9288:7;9279:6;9268:9;9264:22;9232:64;:::i;:::-;9222:74;;9178:128;8962:351;;;;:::o;9319:165::-;9459:17;9455:1;9447:6;9443:14;9436:41;9319:165;:::o;9490:366::-;9632:3;9653:67;9717:2;9712:3;9653:67;:::i;:::-;9646:74;;9729:93;9818:3;9729:93;:::i;:::-;9847:2;9842:3;9838:12;9831:19;;9490:366;;;:::o;9862:419::-;10028:4;10066:2;10055:9;10051:18;10043:26;;10115:9;10109:4;10105:20;10101:1;10090:9;10086:17;10079:47;10143:131;10269:4;10143:131;:::i;:::-;10135:139;;9862:419;;;:::o;10287:158::-;10427:10;10423:1;10415:6;10411:14;10404:34;10287:158;:::o;10451:365::-;10593:3;10614:66;10678:1;10673:3;10614:66;:::i;:::-;10607:73;;10689:93;10778:3;10689:93;:::i;:::-;10807:2;10802:3;10798:12;10791:19;;10451:365;;;:::o;10822:419::-;10988:4;11026:2;11015:9;11011:18;11003:26;;11075:9;11069:4;11065:20;11061:1;11050:9;11046:17;11039:47;11103:131;11229:4;11103:131;:::i;:::-;11095:139;;10822:419;;;:::o;11247:161::-;11387:13;11383:1;11375:6;11371:14;11364:37;11247:161;:::o;11414:366::-;11556:3;11577:67;11641:2;11636:3;11577:67;:::i;:::-;11570:74;;11653:93;11742:3;11653:93;:::i;:::-;11771:2;11766:3;11762:12;11755:19;;11414:366;;;:::o;11786:419::-;11952:4;11990:2;11979:9;11975:18;11967:26;;12039:9;12033:4;12029:20;12025:1;12014:9;12010:17;12003:47;12067:131;12193:4;12067:131;:::i;:::-;12059:139;;11786:419;;;:::o;12211:161::-;12351:13;12347:1;12339:6;12335:14;12328:37;12211:161;:::o;12378:366::-;12520:3;12541:67;12605:2;12600:3;12541:67;:::i;:::-;12534:74;;12617:93;12706:3;12617:93;:::i;:::-;12735:2;12730:3;12726:12;12719:19;;12378:366;;;:::o;12750:419::-;12916:4;12954:2;12943:9;12939:18;12931:26;;13003:9;12997:4;12993:20;12989:1;12978:9;12974:17;12967:47;13031:131;13157:4;13031:131;:::i;:::-;13023:139;;12750:419;;;:::o;13175:442::-;13324:4;13362:2;13351:9;13347:18;13339:26;;13375:71;13443:1;13432:9;13428:17;13419:6;13375:71;:::i;:::-;13456:72;13524:2;13513:9;13509:18;13500:6;13456:72;:::i;:::-;13538;13606:2;13595:9;13591:18;13582:6;13538:72;:::i;:::-;13175:442;;;;;;:::o;13623:233::-;13662:3;13685:24;13703:5;13685:24;:::i;:::-;13676:33;;13731:66;13724:5;13721:77;13718:103;;13801:18;;:::i;:::-;13718:103;13848:1;13841:5;13837:13;13830:20;;13623:233;;;:::o;13862:553::-;14039:4;14077:3;14066:9;14062:19;14054:27;;14091:71;14159:1;14148:9;14144:17;14135:6;14091:71;:::i;:::-;14172:72;14240:2;14229:9;14225:18;14216:6;14172:72;:::i;:::-;14254;14322:2;14311:9;14307:18;14298:6;14254:72;:::i;:::-;14336;14404:2;14393:9;14389:18;14380:6;14336:72;:::i;:::-;13862:553;;;;;;;:::o;14421:161::-;14561:13;14557:1;14549:6;14545:14;14538:37;14421:161;:::o;14588:366::-;14730:3;14751:67;14815:2;14810:3;14751:67;:::i;:::-;14744:74;;14827:93;14916:3;14827:93;:::i;:::-;14945:2;14940:3;14936:12;14929:19;;14588:366;;;:::o;14960:419::-;15126:4;15164:2;15153:9;15149:18;15141:26;;15213:9;15207:4;15203:20;15199:1;15188:9;15184:17;15177:47;15241:131;15367:4;15241:131;:::i;:::-;15233:139;;14960:419;;;:::o;15385:169::-;15525:21;15521:1;15513:6;15509:14;15502:45;15385:169;:::o;15560:366::-;15702:3;15723:67;15787:2;15782:3;15723:67;:::i;:::-;15716:74;;15799:93;15888:3;15799:93;:::i;:::-;15917:2;15912:3;15908:12;15901:19;;15560:366;;;:::o;15932:419::-;16098:4;16136:2;16125:9;16121:18;16113:26;;16185:9;16179:4;16175:20;16171:1;16160:9;16156:17;16149:47;16213:131;16339:4;16213:131;:::i;:::-;16205:139;;15932:419;;;:::o;16357:165::-;16497:17;16493:1;16485:6;16481:14;16474:41;16357:165;:::o;16528:366::-;16670:3;16691:67;16755:2;16750:3;16691:67;:::i;:::-;16684:74;;16767:93;16856:3;16767:93;:::i;:::-;16885:2;16880:3;16876:12;16869:19;;16528:366;;;:::o;16900:419::-;17066:4;17104:2;17093:9;17089:18;17081:26;;17153:9;17147:4;17143:20;17139:1;17128:9;17124:17;17117:47;17181:131;17307:4;17181:131;:::i;:::-;17173:139;;16900:419;;;:::o;17325:175::-;17465:27;17461:1;17453:6;17449:14;17442:51;17325:175;:::o;17506:366::-;17648:3;17669:67;17733:2;17728:3;17669:67;:::i;:::-;17662:74;;17745:93;17834:3;17745:93;:::i;:::-;17863:2;17858:3;17854:12;17847:19;;17506:366;;;:::o;17878:419::-;18044:4;18082:2;18071:9;18067:18;18059:26;;18131:9;18125:4;18121:20;18117:1;18106:9;18102:17;18095:47;18159:131;18285:4;18159:131;:::i;:::-;18151:139;;17878:419;;;:::o

ipfs://e3b446d46d4be8fbd73b874a4e940f3408689a4989942df3d5c56dc07db4a303