Contract 0x61f95bd637e3034133335c1baa0148e518d438ad 3

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.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}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * 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.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * 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 override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override 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 value {ERC20} uses, unless this function is
     * 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 override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override 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 `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        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 `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, _allowances[owner][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = _allowances[owner][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * 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.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` 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.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Spend `amount` form the allowance of `owner` toward `spender`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
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 v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../../../utils/Address.sol";

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./MonthlyVestingWallet.sol";


contract MetaShooterToken is ERC20, Ownable {
    using SafeMath for uint256;

    constructor() ERC20("MetaShooter", "MHUNT") {
        _mint(owner(), seedTokens);
        _mint(owner(), publicSale1Tokens);
        _mint(owner(), publicSale2Tokens);
        generateLockedTokens();
    }

    /// Seed Sale 20.10%
    uint256 constant public seedTokens = 19095000000000000000000000; // 19 095 000 * 10**18

    /// Public Sale 1 10.00%
    uint256 constant public publicSale1Tokens = 9500000000000000000000000; // 9 500 000 * 10**18

    /// Public Sale 2 1.5%
    uint256 constant public publicSale2Tokens = 1425000000000000000000000; // 1 425 000 * 10**18

    // Marketing / Ecosystem 42.10%
    uint256 constant public marketingTokens = 39995000000000000000000000; // 19 350 000 * 10**18

    // Team / Advisers 10.50%
    uint256 constant public teamTokens = 9975000000000000000000000; // 18 060 000 * 10**18

    // Liquidity 15.80%
    uint256 constant public liquidityTokens = 15010000000000000000000000; // 24 510 000 * 10**18

    address public marketingVestingWallet;
    address public teamVestingWallet;
    address public liquidityVestingWallet;

    uint64[] public marketingSchedule = [0, 1, 1, 1, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 5];
    uint64[] public teamSchedule = [0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10];
    uint64[] public liquiditySchedule = [0, 5, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

    uint64 constant internal SECONDS_PER_MONTH = 2628288;
    uint64 constant internal SECONDS_PER_WEEK = SECONDS_PER_MONTH/4;

    // April 21, 2022 16:00:00
    uint256 public constant dateSaleEnd = 1650556800;

    function generateLockedTokens() internal {
        generateTeamTokens();
        generateMarketingTokens();
        generateLiquidityTokens();
    }

    function generateLiquidityTokens() internal{
        MonthlyVestingWallet lockedTokens = new MonthlyVestingWallet(owner(), uint64(dateSaleEnd), 5, liquiditySchedule, SECONDS_PER_WEEK);
        liquidityVestingWallet = address(lockedTokens);
        _mint(liquidityVestingWallet, liquidityTokens);
    }

    function generateTeamTokens() internal{
        MonthlyVestingWallet lockedTokens = new MonthlyVestingWallet(owner(), uint64(dateSaleEnd), 0, teamSchedule, SECONDS_PER_MONTH);
        teamVestingWallet = address(lockedTokens);
        _mint(teamVestingWallet, teamTokens);
    }

    function generateMarketingTokens() internal{
        MonthlyVestingWallet lockedTokens = new MonthlyVestingWallet(owner(), uint64(dateSaleEnd), 2, marketingSchedule, SECONDS_PER_MONTH);
        marketingVestingWallet = address(lockedTokens);
        _mint(marketingVestingWallet, marketingTokens);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.3.2 (finance/VestingWallet.sol)
pragma solidity ^0.8.9;

import "./VestingWallet.sol";


contract MonthlyVestingWallet is VestingWallet {
    uint64[] public _schedule;
    uint64 public immutable _scheduleInterval;
    uint64 public immutable _initialMintingPercent;
    address public immutable _beneficiary;
    uint64 private _start;

    uint64 constant internal SECONDS_PER_MONTH = 2628288;

    /**
     * @dev Set the beneficiary, start timestamp and vesting duration of the vesting wallet.
     */
    constructor(
        address beneficiaryAddress,
        uint64 startTimestamp,
        uint64 initialMintingPercent,
        uint64[] memory schedule,
        uint64 scheduleInterval
    ) VestingWallet(beneficiaryAddress, startTimestamp, uint64(schedule.length) * scheduleInterval){
        require(beneficiaryAddress != address(0), "MonthlyVestingWallet: beneficiary is zero address");
        _beneficiary = beneficiaryAddress;
        _start = startTimestamp;
        _initialMintingPercent = initialMintingPercent;
        _schedule = schedule;
        _scheduleInterval = scheduleInterval;
    }


    /**
     * @dev Virtual implementation of the vesting formula. This returns the amount vested, as a function of time, for
     * an asset given its total historical allocation.
     */
    function _vestingSchedule(uint256 totalAllocation, uint64 timestamp) internal view virtual override returns (uint256) {
        return totalAllocation * monthlyVestingPercent(timestamp) / 10000;
    }

    /**
     * @dev Calculates the percentage of tokens that has already vested as a function of time.
     */
    function monthlyVestingPercent(uint64 timestamp) public view returns (uint64) {
        if (timestamp < start()) {
            return 0;
        } else if (timestamp > start() + duration()) {
            return 10000;
        }

        uint64 secondsAfterStart = timestamp - uint64(start());
        uint64 step = secondsAfterStart / _scheduleInterval;
        return getStepPercent(step+1);
    }

    /**
     * @dev Calculates the percentage of tokens in specific step of vesting
     */
    function getStepPercent(uint step) public view returns (uint64) {
        uint64 acumulatedPercent = _initialMintingPercent;
        for (uint i = 0; i < step; i++) {
            acumulatedPercent += _schedule[i];
        }
        return acumulatedPercent * 100;
    }

}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.3.2 (finance/VestingWallet.sol)
pragma solidity ^0.8.9;

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";

/**
 * @title VestingWallet
 * @dev This contract handles the vesting of Eth and ERC20 tokens for a given beneficiary. Custody of multiple tokens
 * can be given to this contract, which will release the token to the beneficiary following a given vesting schedule.
 * The vesting schedule is customizable through the {vestedAmount} function.
 *
 * Any token transferred to this contract will follow the vesting schedule as if they were locked from the beginning.
 * Consequently, if the vesting has already started, any amount of tokens sent to this contract will (at least partly)
 * be immediately releasable.
 */
contract VestingWallet is Context {
    event EtherReleased(uint256 amount);
    event ERC20Released(address token, uint256 amount);

    uint256 private _released;
    mapping(address => uint256) private _erc20Released;
    address private immutable _beneficiary;
    uint64 private immutable _start;
    uint64 private immutable _duration;

    /**
     * @dev Set the beneficiary, start timestamp and vesting duration of the vesting wallet.
     */
    constructor(
        address beneficiaryAddress,
        uint64 startTimestamp,
        uint64 durationSeconds
    ) {
        require(beneficiaryAddress != address(0), "VestingWallet: beneficiary is zero address");
        _beneficiary = beneficiaryAddress;
        _start = startTimestamp;
        _duration = durationSeconds;
    }

    /**
     * @dev The contract should be able to receive Eth.
     */
    receive() external payable virtual {}

    /**
     * @dev Getter for the beneficiary address.
     */
    function beneficiary() public view virtual returns (address) {
        return _beneficiary;
    }

    /**
     * @dev Getter for the start timestamp.
     */
    function start() public view virtual returns (uint256) {
        return _start;
    }

    /**
     * @dev Getter for the vesting duration.
     */
    function duration() public view virtual returns (uint256) {
        return _duration;
    }

    /**
     * @dev Amount of eth already released
     */
    function released() public view virtual returns (uint256) {
        return _released;
    }

    /**
     * @dev Amount of token already released
     */
    function releasedToken(address token) public view virtual returns (uint256) {
        return _erc20Released[token];
    }

    /**
     * @dev Release the native token (ether) that have already vested.
     *
     * Emits a {TokensReleased} event.
     */
    function release() public virtual {
        uint256 releasable = vestedAmount(uint64(block.timestamp)) - released();
        _released += releasable;
        emit EtherReleased(releasable);
        Address.sendValue(payable(beneficiary()), releasable);
    }

    /**
     * @dev Release the tokens that have already vested.
     *
     * Emits a {TokensReleased} event.
     */
    function releaseToken(address token) public virtual {
        uint256 releasable = vestedAmountToken(token, uint64(block.timestamp)) - releasedToken(token);
        _erc20Released[token] += releasable;
        emit ERC20Released(token, releasable);
        SafeERC20.safeTransfer(IERC20(token), beneficiary(), releasable);
    }

    /**
     * @dev Calculates the amount of ether that has already vested. Default implementation is a linear vesting curve.
     */
    function vestedAmount(uint64 timestamp) public view virtual returns (uint256) {
        return _vestingSchedule(address(this).balance + released(), timestamp);
    }

    /**
     * @dev Calculates the amount of tokens that has already vested. Default implementation is a linear vesting curve.
     */
    function vestedAmountToken(address token, uint64 timestamp) public view virtual returns (uint256) {
        return _vestingSchedule(IERC20(token).balanceOf(address(this)) + releasedToken(token), timestamp);
    }

    /**
     * @dev Virtual implementation of the vesting formula. This returns the amount vested, as a function of time, for
     * an asset given its total historical allocation.
     */
    function _vestingSchedule(uint256 totalAllocation, uint64 timestamp) internal view virtual returns (uint256) {
        if (timestamp < start()) {
            return 0;
        } else if (timestamp > start() + duration()) {
            return totalAllocation;
        } else {


            return (totalAllocation * (timestamp - start())) / duration();
        }
    }
}

{
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dateSaleEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"liquiditySchedule","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityVestingWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"marketingSchedule","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingVestingWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSale1Tokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSale2Tokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"seedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"teamSchedule","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamVestingWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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