Token

AI AKITA INU (AIAI)

ERC-20

Overview

Max Total Supply

1,000,000,000,000,000 AIAI

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x39b35764b6c676299bdb2bc0f964282e9f17e5ad

Filtered by Token Holder

0x8eFd248E568948CB914a4f672a169Bc0D7B7AeA0

pitake.eth

Balance

0 AIAI

Value

$0.00

0x8efd248e568948cb914a4f672a169bc0d7b7aea0

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

AIAkitaInu

Compiler Version

v0.8.19+commit.7dd6d404

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-04-30
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/Context.sol

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;



/**
 * @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.openzeppelin.com/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, allowance(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 = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
    unchecked {
        _approve(owner, spender, currentAllowance - subtractedValue);
    }

        return true;
    }

    /**
     * @dev Moves `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.
     *
     * 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;
        // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
        // decrementing then incrementing.
        _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;
    unchecked {
        // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
        _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;
        // Overflow not possible: amount <= accountBalance <= totalSupply.
        _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 Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * 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 {}
}

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

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

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

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

// File: @openzeppelin/contracts/utils/Address.sol

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/access/Ownable.sol

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

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

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

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

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

// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol

// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// File: contracts/interfaces/ICamelotFactory.sol


pragma solidity >=0.5.0;

interface IUniswapV2Factory {
  event PairCreated(address indexed token0, address indexed token1, address pair, uint256);

  function feeTo() external view returns (address);

  function feeToSetter() external view returns (address);

  function getPair(address tokenA, address tokenB) external view returns (address pair);

  function allPairs(uint256) external view returns (address pair);

  function allPairsLength() external view returns (uint256);

  function createPair(address tokenA, address tokenB) external returns (address pair);

  function setFeeTo(address) external;

  function setFeeToSetter(address) external;
}


// File: contracts/interfaces/IUniswapV2Router01.sol


pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
 function factory() external pure returns (address);

 function WETH() external pure returns (address);

 function addLiquidity(
     address tokenA,
     address tokenB,
     uint256 amountADesired,
     uint256 amountBDesired,
     uint256 amountAMin,
     uint256 amountBMin,
     address to,
     uint256 deadline
 )
 external
 returns (
     uint256 amountA,
     uint256 amountB,
     uint256 liquidity
 );

 function addLiquidityETH(
     address token,
     uint256 amountTokenDesired,
     uint256 amountTokenMin,
     uint256 amountETHMin,
     address to,
     uint256 deadline
 )
 external
 payable
 returns (
     uint256 amountToken,
     uint256 amountETH,
     uint256 liquidity
 );

 function removeLiquidity(
     address tokenA,
     address tokenB,
     uint256 liquidity,
     uint256 amountAMin,
     uint256 amountBMin,
     address to,
     uint256 deadline
 ) external returns (uint256 amountA, uint256 amountB);

 function removeLiquidityETH(
     address token,
     uint256 liquidity,
     uint256 amountTokenMin,
     uint256 amountETHMin,
     address to,
     uint256 deadline
 ) external returns (uint256 amountToken, uint256 amountETH);

 function removeLiquidityWithPermit(
     address tokenA,
     address tokenB,
     uint256 liquidity,
     uint256 amountAMin,
     uint256 amountBMin,
     address to,
     uint256 deadline,
     bool approveMax,
     uint8 v,
     bytes32 r,
     bytes32 s
 ) external returns (uint256 amountA, uint256 amountB);

 function removeLiquidityETHWithPermit(
     address token,
     uint256 liquidity,
     uint256 amountTokenMin,
     uint256 amountETHMin,
     address to,
     uint256 deadline,
     bool approveMax,
     uint8 v,
     bytes32 r,
     bytes32 s
 ) external returns (uint256 amountToken, uint256 amountETH);

 function swapExactTokensForTokens(
     uint256 amountIn,
     uint256 amountOutMin,
     address[] calldata path,
     address to,
     uint256 deadline
 ) external returns (uint256[] memory amounts);

 function swapTokensForExactTokens(
     uint256 amountOut,
     uint256 amountInMax,
     address[] calldata path,
     address to,
     uint256 deadline
 ) external returns (uint256[] memory amounts);

 function swapExactETHForTokens(
     uint256 amountOutMin,
     address[] calldata path,
     address to,
     uint256 deadline
 ) external payable returns (uint256[] memory amounts);

 function swapTokensForExactETH(
     uint256 amountOut,
     uint256 amountInMax,
     address[] calldata path,
     address to,
     uint256 deadline
 ) external returns (uint256[] memory amounts);

 function swapExactTokensForETH(
     uint256 amountIn,
     uint256 amountOutMin,
     address[] calldata path,
     address to,
     uint256 deadline
 ) external returns (uint256[] memory amounts);

 function swapETHForExactTokens(
     uint256 amountOut,
     address[] calldata path,
     address to,
     uint256 deadline
 ) external payable returns (uint256[] memory amounts);

 function quote(
     uint256 amountA,
     uint256 reserveA,
     uint256 reserveB
 ) external pure returns (uint256 amountB);

 function getAmountOut(
     uint256 amountIn,
     uint256 reserveIn,
     uint256 reserveOut
 ) external pure returns (uint256 amountOut);

 function getAmountIn(
     uint256 amountOut,
     uint256 reserveIn,
     uint256 reserveOut
 ) external pure returns (uint256 amountIn);

 function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);

 function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
}


// File: contracts/interfaces/IUniswapV2Router02.sol

pragma solidity >=0.6.2;

interface IUniswapV2Router02 is IUniswapV2Router01 {
  function removeLiquidityETHSupportingFeeOnTransferTokens(
      address token,
      uint256 liquidity,
      uint256 amountTokenMin,
      uint256 amountETHMin,
      address to,
      uint256 deadline
  ) external returns (uint256 amountETH);

  function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
      address token,
      uint256 liquidity,
      uint256 amountTokenMin,
      uint256 amountETHMin,
      address to,
      uint256 deadline,
      bool approveMax,
      uint8 v,
      bytes32 r,
      bytes32 s
  ) external returns (uint256 amountETH);

  function swapExactTokensForTokensSupportingFeeOnTransferTokens(
      uint256 amountIn,
      uint256 amountOutMin,
      address[] calldata path,
      address to,
      uint256 deadline
  ) external;

  function swapExactETHForTokensSupportingFeeOnTransferTokens(
      uint256 amountOutMin,
      address[] calldata path,
      address to,
      uint256 deadline
  ) external payable;

  function swapExactTokensForETHSupportingFeeOnTransferTokens(
      uint256 amountIn,
      uint256 amountOutMin,
      address[] calldata path,
      address to,
      uint256 deadline
  ) external;
}



// File: contracts/interfaces/IWETH.sol


pragma solidity >=0.5.0;

interface IWETH {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function deposit() external payable;

    function transfer(address to, uint256 value) external returns (bool);

    function withdraw(uint256) external;
}


// File: contracts/token/AkitaInu.sol


pragma solidity =0.8.19;

contract AIAkitaInu is ERC20, Ownable {
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.AddressSet;

    event SwapBack(uint256 burn, uint256 gov, uint256 bonus, uint256 liquidity, uint256 jackpot, uint timestamp);
    event Trade(address user, address pair, uint256 amount, uint side, uint256 circulatingSupply, uint timestamp);
    event AddLiquidity(uint256 tokenAmount, uint256 ethAmount, uint256 timestamp);

    bool public swapEnabled = true;
    bool public addLiquidityEnabled = true;

    bool public inSwap;
    modifier swapping() {
        inSwap = true;
        _;
        inSwap = false;
    }

    mapping(address => bool) public isFeeExempt;
    mapping(address => bool) public canAddLiquidityBeforeLaunch;

    uint256 private burnFee;
    uint256 public govFee;
    uint256 public bonusFee;
    uint256 private liquidityFee;
    uint256 private jackpotFee;
    uint256 private totalFee;
    uint256 public feeDenominator = 10000;

    // Buy Fees
    uint256 public burnFeeBuy = 50;
    uint256 public govFeeBuy = 50;
    uint256 public bonusFeeBuy = 50;
    uint256 public liquidityFeeBuy = 50;
    uint256 public jackpotFeeBuy = 100;
    uint256 public totalFeeBuy = 300;
    // Sell Fees
    uint256 public burnFeeSell = 50;
    uint256 public govFeeSell = 50;
    uint256 public bonusFeeSell = 50;
    uint256 public liquidityFeeSell = 50;
    uint256 public jackpotFeeSell = 100;
    uint256 public totalFeeSell = 300;

    // Fees receivers
    address public govWallet;
    address public bonusWallet;
    address public jackpotWallet;

    uint256 public launchedAt;
    uint256 public launchedAtTimestamp;
    bool private initialized;

    IUniswapV2Factory private immutable factory;
    IUniswapV2Router02 public immutable swapRouter;
    IWETH public immutable WETH;
    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
    address private constant ZERO = 0x0000000000000000000000000000000000000000;

    EnumerableSet.AddressSet private _pairs;

    constructor(
        address _factory,
        address _swapRouter,
        address _weth
    ) ERC20("AI AKITA INU", "AIAI") {
        uint256 _totalSupply = 1000_000_000_000_000 * 1e18;
        canAddLiquidityBeforeLaunch[_msgSender()] = true;
        canAddLiquidityBeforeLaunch[address(this)] = true;
        isFeeExempt[msg.sender] = true;
        isFeeExempt[address(this)] = true;
        factory = IUniswapV2Factory(_factory);
        swapRouter = IUniswapV2Router02(_swapRouter);
        WETH = IWETH(_weth);
        govWallet = address(0x419660977123C9669056Aa0B5F5436a2Ef7AcF6A);
        bonusWallet= address(0x465a8FcB96FA19a2e25a21A50762Fe1031Edc5AD);
        jackpotWallet= address(0xaCDbe7caF9162C68C72c14443234931fBfc75483);
        _mint(_msgSender(), _totalSupply);
    }

    function initializePair() external onlyOwner {
        require(!initialized, "Already initialized");
        address pair = factory.createPair(address(WETH), address(this));
        _pairs.add(pair);
        initialized = true;
    }

    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        return _akitaTransfer(_msgSender(), to, amount);
    }

    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(sender, spender, amount);
        return _akitaTransfer(sender, recipient, amount);
    }

    function _akitaTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
        if (inSwap) {
            _transfer(sender, recipient, amount);
            return true;
        }
        if (!canAddLiquidityBeforeLaunch[sender]) {
            require(launched(), "Trading not open yet");
        }

        bool shouldTakeFee = (!isFeeExempt[sender] && !isFeeExempt[recipient]) && launched();
        uint side = 0;
        address user_ = sender;
        address pair_ = recipient;
        // Set Fees
        if (isPair(sender)) {
            buyFees();
            side = 1;
            user_ = recipient;
            pair_ = sender;
        } else if (isPair(recipient)) {
            sellFees();
            side = 2;
        } else {
            shouldTakeFee = false;
        }

        if (shouldSwapBack()) {
            swapBack();
        }

        uint256 amountReceived = shouldTakeFee ? takeFee(sender, amount) : amount;
        _transfer(sender, recipient, amountReceived);

        if (side > 0) {
            emit Trade(user_, pair_, amount, side, getCirculatingSupply(), block.timestamp);
        }
        return true;
    }

    function shouldSwapBack() internal view returns (bool) {
        return !inSwap && swapEnabled && launched() && balanceOf(address(this)) > 0 && !isPair(_msgSender());
    }

    function swapBack() internal swapping {
        uint256 taxAmount = balanceOf(address(this));
        _approve(address(this), address(swapRouter), taxAmount);

        uint256 amountAkitaBurn = (taxAmount * burnFee) / (totalFee);
        uint256 amountAkitaLp = (taxAmount * liquidityFee) / (totalFee);
        taxAmount -= amountAkitaBurn;
        taxAmount -= amountAkitaLp;

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = address(WETH);

        bool success = false;
        uint256 balanceBefore = address(this).balance;
        try swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(taxAmount,0,path,address(this),block.timestamp) {
            success = true;
        }
        catch {}

        if (!success) {
            return;
        }

        _transfer(address(this), DEAD, amountAkitaBurn);

        uint256 amountBackToken = address(this).balance - balanceBefore;
        uint256 backTokenTotalFee = totalFee - burnFee - liquidityFee;
        uint256 amountBackTokenGov = (amountBackToken * govFee) / (backTokenTotalFee);
        uint256 amountBackTokenBonus = (amountBackToken * bonusFee) / (backTokenTotalFee);
        uint256 amountBackTokenJackpot = amountBackToken - amountBackTokenGov - amountBackTokenBonus;

        payable(address(govWallet)).call{value: amountBackTokenGov}("");
        payable(address(bonusWallet)).call{value: amountBackTokenBonus}("");
        payable(address(jackpotWallet)).call{value: amountBackTokenJackpot}("");

        if (addLiquidityEnabled) {
            _doAddLp();
        }

        emit SwapBack(amountAkitaBurn, amountBackTokenGov, amountBackTokenBonus, amountAkitaLp, amountBackTokenJackpot, block.timestamp);
    }

    function _doAddLp() internal {
        address[] memory pathEth = new address[](2);
        pathEth[0] = address(this);
        pathEth[1] = address(WETH);

        uint256 tokenAmount = balanceOf(address(this));
        uint256 half = tokenAmount / 2;
        if(half < 1000) return;

        uint256 ethAmountBefore = address(this).balance;
        bool success = false;

        try swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(half,0, pathEth,address(this),block.timestamp){
            success = true;
        } catch {}

        if (!success) {
            return;
        }

        uint256 ethAmount = address(this).balance - ethAmountBefore;
        _addLiquidity(half, ethAmount);
    }

    function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
        _approve(address(this), address(swapRouter), tokenAmount);
        try swapRouter.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, address(0), block.timestamp) {
            emit AddLiquidity(tokenAmount, ethAmount, block.timestamp);
        } catch {}
    }

    function doSwapBack() public onlyOwner {
        swapBack();
    }

    function launched() internal view returns (bool) {
        return launchedAt != 0;
    }

    function buyFees() internal {
        burnFee = burnFeeBuy;
        govFee = govFeeBuy;
        bonusFee = bonusFeeBuy;
        liquidityFee = liquidityFeeBuy;
        jackpotFee = jackpotFeeBuy;
        totalFee = totalFeeBuy;
    }

    function sellFees() internal {
        burnFee = burnFeeSell;
        govFee = govFeeSell;
        bonusFee = bonusFeeSell;
        liquidityFee = liquidityFeeSell;
        jackpotFee = jackpotFeeSell;
        totalFee = totalFeeSell;
    }

    function takeFee(address sender, uint256 amount) internal returns (uint256) {
        uint256 feeAmount = (amount * totalFee) / feeDenominator;
        _transfer(sender, address(this), feeAmount);
        return amount - feeAmount;
    }

    function rescueToken(address tokenAddress) external onlyOwner {
        IERC20(tokenAddress).safeTransfer(msg.sender,IERC20(tokenAddress).balanceOf(address(this)));
    }

    function clearStuckEthBalance() external onlyOwner {
        uint256 amountETH = address(this).balance;
        (bool success, ) = payable(_msgSender()).call{value: amountETH}(new bytes(0));
        require(success, 'AKITAINU: ETH_TRANSFER_FAILED');
    }

    function clearStuckBalance(address _tokenStuck) external onlyOwner {
        IERC20(_tokenStuck).transfer(_msgSender(), IERC20(_tokenStuck).balanceOf(address(this)));
    }

    function getCirculatingSupply() public view returns (uint256) {
        return totalSupply() - balanceOf(DEAD) - balanceOf(ZERO);
    }

    /*** ADMIN FUNCTIONS ***/
    function launch() public onlyOwner {
        require(launchedAt == 0, "Already launched");
        launchedAt = block.number;
        launchedAtTimestamp = block.timestamp;
    }

    function setBuyFees(
        uint256 _govFee,
        uint256 _bonusFee,
        uint256 _liquidityFee,
        uint256 _jackpotFee,
        uint256 _burnFee
    ) external onlyOwner {
        govFeeBuy = _govFee;
        bonusFeeBuy = _bonusFee;
        liquidityFeeBuy = _liquidityFee;
        jackpotFeeBuy = _jackpotFee;
        burnFeeBuy = _burnFee;
        totalFeeBuy = _govFee+ _bonusFee + _liquidityFee + _jackpotFee + _burnFee;
    }

    function setSellFees(
        uint256 _govFee,
        uint256 _bonusFee,
        uint256 _liquidityFee,
        uint256 _jackpotFee,
        uint256 _burnFee
    ) external onlyOwner {
        govFeeSell = _govFee;
        bonusFeeSell = _bonusFee;
        liquidityFeeSell = _liquidityFee;
        jackpotFeeSell = _jackpotFee;
        burnFeeSell = _burnFee;
        totalFeeSell = _govFee+ _bonusFee + _liquidityFee + _jackpotFee + _burnFee;
    }

    function setFeeReceivers(
        address _govWallet,
        address _bonusWallet,
        address _jackpotWallet
    ) external onlyOwner {
        govWallet = _govWallet;
        bonusWallet = _bonusWallet;
        jackpotWallet = _jackpotWallet;
    }

    function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
        isFeeExempt[holder] = exempt;
    }

    function setSwapBackSettings(bool _enabled) external onlyOwner {
        swapEnabled = _enabled;
    }

    function setAddLiquidityEnabled(bool _enabled) external onlyOwner {
        addLiquidityEnabled = _enabled;
    }

    function isPair(address account) public view returns (bool) {
        return _pairs.contains(account);
    }

    function addPair(address pair) public onlyOwner returns (bool) {
        require(pair != address(0), "AKITAINU: pair is the zero address");
        return _pairs.add(pair);
    }

    function delPair(address pair) public onlyOwner returns (bool) {
        require(pair != address(0), "AKITAINU: pair is the zero address");
        return _pairs.remove(pair);
    }

    function getMinterLength() public view returns (uint256) {
        return _pairs.length();
    }

    function getPair(uint256 index) public view returns (address) {
        require(index <= _pairs.length() - 1, "AKITAINU: index out of bounds");
        return _pairs.at(index);
    }

    receive() external payable {}
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_swapRouter","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AddLiquidity","type":"event"},{"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":false,"internalType":"uint256","name":"burn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gov","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"bonus","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"liquidity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"jackpot","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"SwapBack","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"side","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"circulatingSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Trade","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":[],"name":"WETH","outputs":[{"internalType":"contract IWETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"addLiquidityEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"addPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"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":"bonusFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"canAddLiquidityBeforeLaunch","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenStuck","type":"address"}],"name":"clearStuckBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"clearStuckEthBalance","outputs":[],"stateMutability":"nonpayable","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":"pair","type":"address"}],"name":"delPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"doSwapBack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCirculatingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinterLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"govFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"govFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"govFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"govWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inSwap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":[],"name":"initializePair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"jackpotFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"jackpotFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"jackpotWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"launchedAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launchedAtTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"rescueToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setAddLiquidityEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_govFee","type":"uint256"},{"internalType":"uint256","name":"_bonusFee","type":"uint256"},{"internalType":"uint256","name":"_liquidityFee","type":"uint256"},{"internalType":"uint256","name":"_jackpotFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"}],"name":"setBuyFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_govWallet","type":"address"},{"internalType":"address","name":"_bonusWallet","type":"address"},{"internalType":"address","name":"_jackpotWallet","type":"address"}],"name":"setFeeReceivers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_govFee","type":"uint256"},{"internalType":"uint256","name":"_bonusFee","type":"uint256"},{"internalType":"uint256","name":"_liquidityFee","type":"uint256"},{"internalType":"uint256","name":"_jackpotFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"}],"name":"setSellFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setSwapBackSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapRouter","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"sender","type":"address"},{"internalType":"address","name":"recipient","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"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

-----Decoded View---------------
Arg [0] : _factory (address): 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f
Arg [1] : _swapRouter (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [2] : _weth (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f
Arg [1] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [2] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

Deployed Bytecode Sourcemap

56745:12223:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66378:182;;;;;;;;;;;;;:::i;:::-;;68637:98;;;;;;;;;;;;;:::i;:::-;;;160:25:1;;;148:2;133:18;68637:98:0;;;;;;;;6672:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;9023:201::-;;;;;;;;;;-1:-1:-1;9023:201:0;;;;;:::i;:::-;;:::i;:::-;;;1473:14:1;;1466:22;1448:41;;1436:2;1421:18;9023:201:0;1308:187:1;58136:36:0;;;;;;;;;;;;;;;;57771:30;;;;;;;;;;;;;;;;57708:37;;;;;;;;;;;;;;;;7792:108;;;;;;;;;;-1:-1:-1;7880:12:0;;7792:108;;58317:26;;;;;;;;;;-1:-1:-1;58317:26:0;;;;-1:-1:-1;;;;;58317:26:0;;;;;;-1:-1:-1;;;;;1664:32:1;;;1646:51;;1634:2;1619:18;58317:26:0;1500:203:1;58022:31:0;;;;;;;;;;;;;;;;60061:271;;;;;;;;;;-1:-1:-1;60061:271:0;;;;;:::i;:::-;;:::i;66202:137::-;;;;;;;;;;;;;:::i;58350:28::-;;;;;;;;;;-1:-1:-1;58350:28:0;;;;-1:-1:-1;;;;;58350:28:0;;;7634:93;;;;;;;;;;-1:-1:-1;7634:93:0;;7717:2;2311:36:1;;2299:2;2284:18;7634:93:0;2169:184:1;10508:238:0;;;;;;;;;;-1:-1:-1;10508:238:0;;;;;:::i;:::-;;:::i;57403:43::-;;;;;;;;;;-1:-1:-1;57403:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;65573:172;;;;;;;;;;-1:-1:-1;65573:172:0;;;;;:::i;:::-;;:::i;66568:457::-;;;;;;;;;;-1:-1:-1;66568:457:0;;;;;:::i;:::-;;:::i;59656:238::-;;;;;;;;;;;;;:::i;58221:33::-;;;;;;;;;;;;;;;;57551:21;;;;;;;;;;;;;;;;67776:119;;;;;;;;;;-1:-1:-1;67776:119:0;;;;;:::i;:::-;;:::i;57924:34::-;;;;;;;;;;;;;;;;57197:30;;;;;;;;;;-1:-1:-1;57197:30:0;;;;-1:-1:-1;;;57197:30:0;;;;;;7963:127;;;;;;;;;;-1:-1:-1;7963:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;8064:18:0;8037:7;8064:18;;;;;;;;;;;;7963:127;35920:103;;;;;;;;;;;;;:::i;66020:174::-;;;;;;;;;;-1:-1:-1;66020:174:0;;;;;:::i;:::-;;:::i;57453:59::-;;;;;;;;;;-1:-1:-1;57453:59:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;57808:29;;;;;;;;;;;;;;;;57882:35;;;;;;;;;;;;;;;;57234:38;;;;;;;;;;-1:-1:-1;57234:38:0;;;;-1:-1:-1;;;57234:38:0;;;;;;57844:31;;;;;;;;;;;;;;;;35272:87;;;;;;;;;;-1:-1:-1;35345:6:0;;-1:-1:-1;;;;;35345:6:0;35272:87;;64647:68;;;;;;;;;;;;;:::i;6891:104::-;;;;;;;;;;;;;:::i;11249:424::-;;;;;;;;;;-1:-1:-1;11249:424:0;;;;;:::i;:::-;;:::i;57579:23::-;;;;;;;;;;;;;;;;68445:184;;;;;;;;;;-1:-1:-1;68445:184:0;;;;;:::i;:::-;;:::i;59902:151::-;;;;;;;;;;-1:-1:-1;59902:151:0;;;;;:::i;:::-;;:::i;68015:115::-;;;;;;;;;;-1:-1:-1;68015:115:0;;;;;:::i;:::-;;:::i;58097:32::-;;;;;;;;;;;;;;;;58596:27;;;;;;;;;;;;;;;58179:35;;;;;;;;;;;;;;;;67903:104;;;;;;;;;;-1:-1:-1;67903:104:0;;;;;:::i;:::-;;:::i;68743:185::-;;;;;;;;;;-1:-1:-1;68743:185:0;;;;;:::i;:::-;;:::i;58387:25::-;;;;;;;;;;;;;;;;65753:259;;;;;;;;;;;;;:::i;67033:464::-;;;;;;;;;;-1:-1:-1;67033:464:0;;;;;:::i;:::-;;:::i;68256:181::-;;;;;;;;;;-1:-1:-1;68256:181:0;;;;;:::i;:::-;;:::i;58543:46::-;;;;;;;;;;;;;;;58419:34;;;;;;;;;;;;;;;;58286:24;;;;;;;;;;-1:-1:-1;58286:24:0;;;;-1:-1:-1;;;;;58286:24:0;;;67505:263;;;;;;;;;;-1:-1:-1;67505:263:0;;;;;:::i;:::-;;:::i;57281:18::-;;;;;;;;;;-1:-1:-1;57281:18:0;;;;-1:-1:-1;;;57281:18:0;;;;;;8552:151;;;;;;;;;;-1:-1:-1;8552:151:0;;;;;:::i;:::-;;:::i;68138:110::-;;;;;;;;;;-1:-1:-1;68138:110:0;;;;;:::i;:::-;;:::i;36178:201::-;;;;;;;;;;-1:-1:-1;36178:201:0;;;;;:::i;:::-;;:::i;57965:32::-;;;;;;;;;;;;;;;;58060:30;;;;;;;;;;;;;;;;66378:182;35158:13;:11;:13::i;:::-;66432:10:::1;::::0;:15;66424:44:::1;;;::::0;-1:-1:-1;;;66424:44:0;;5596:2:1;66424:44:0::1;::::0;::::1;5578:21:1::0;5635:2;5615:18;;;5608:30;-1:-1:-1;;;5654:18:1;;;5647:46;5710:18;;66424:44:0::1;;;;;;;;;66492:12;66479:10;:25:::0;66537:15:::1;66515:19;:37:::0;66378:182::o;68637:98::-;68685:7;68712:15;:6;:13;:15::i;:::-;68705:22;;68637:98;:::o;6672:100::-;6726:13;6759:5;6752:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6672:100;:::o;9023:201::-;9106:4;4398:10;9162:32;4398:10;9178:7;9187:6;9162:8;:32::i;:::-;9212:4;9205:11;;;9023:201;;;;;:::o;60061:271::-;60167:4;4398:10;60225:40;60241:6;4398:10;60258:6;60225:15;:40::i;:::-;60283:41;60298:6;60306:9;60317:6;60283:14;:41::i;:::-;60276:48;;;60061:271;;;;;;:::o;66202:137::-;66255:7;8064:18;;;;;;58662:42;8064:18;;;;7880:12;;66282:31;;8064:18;66282:31;:::i;:::-;:49;;;;:::i;10508:238::-;10596:4;4398:10;10652:64;4398:10;10668:7;10705:10;10677:25;4398:10;10668:7;10677:9;:25::i;:::-;:38;;;;:::i;:::-;10652:8;:64::i;65573:172::-;35158:13;:11;:13::i;:::-;65691:45:::1;::::0;-1:-1:-1;;;65691:45:0;;65730:4:::1;65691:45;::::0;::::1;1646:51:1::0;65646:91:0::1;::::0;65680:10:::1;::::0;-1:-1:-1;;;;;65691:30:0;::::1;::::0;::::1;::::0;1619:18:1;;65691:45:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;65646:33:0;::::1;::::0;:91;:33:::1;:91::i;:::-;65573:172:::0;:::o;66568:457::-;35158:13;:11;:13::i;:::-;66768:9:::1;:19:::0;;;66798:11:::1;:23:::0;;;66832:15:::1;:31:::0;;;66874:13:::1;:27:::0;;;66912:10:::1;:21:::0;;;66925:8;66890:11;66850:13;66958:18:::1;66812:9:::0;66780:7;66958:18:::1;:::i;:::-;:34;;;;:::i;:::-;:48;;;;:::i;:::-;:59;;;;:::i;:::-;66944:11;:73:::0;-1:-1:-1;;;;;66568:457:0:o;59656:238::-;35158:13;:11;:13::i;:::-;59721:11:::1;::::0;::::1;;59720:12;59712:44;;;::::0;-1:-1:-1;;;59712:44:0;;6910:2:1;59712:44:0::1;::::0;::::1;6892:21:1::0;6949:2;6929:18;;;6922:30;-1:-1:-1;;;6968:18:1;;;6961:49;7027:18;;59712:44:0::1;6708:343:1::0;59712:44:0::1;59782:48;::::0;-1:-1:-1;;;59782:48:0;;-1:-1:-1;;;;;59809:4:0::1;7286:15:1::0;;59782:48:0::1;::::0;::::1;7268:34:1::0;59824:4:0::1;7318:18:1::0;;;7311:43;-1:-1:-1;;59782:7:0::1;:18:::0;;::::1;::::0;::::1;::::0;7203::1;;59782:48:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59767:63:::0;-1:-1:-1;59841:16:0::1;:6;59767:63:::0;59841:10:::1;:16::i;:::-;-1:-1:-1::0;;59868:11:0::1;:18:::0;;-1:-1:-1;;59868:18:0::1;59882:4;59868:18;::::0;;59656:238::o;67776:119::-;35158:13;:11;:13::i;:::-;-1:-1:-1;;;;;67859:19:0;;;::::1;;::::0;;;:11:::1;:19;::::0;;;;:28;;-1:-1:-1;;67859:28:0::1;::::0;::::1;;::::0;;;::::1;::::0;;67776:119::o;35920:103::-;35158:13;:11;:13::i;:::-;35985:30:::1;36012:1;35985:18;:30::i;:::-;35920:103::o:0;66020:174::-;35158:13;:11;:13::i;:::-;-1:-1:-1;;;;;66098:28:0;::::1;;4398:10:::0;66141:44:::1;::::0;-1:-1:-1;;;66141:44:0;;66179:4:::1;66141:44;::::0;::::1;1646:51:1::0;-1:-1:-1;;;;;66141:29:0;::::1;::::0;::::1;::::0;1619:18:1;;66141:44:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66098:88;::::0;-1:-1:-1;;;;;;66098:88:0::1;::::0;;;;;;-1:-1:-1;;;;;7813:32:1;;;66098:88:0::1;::::0;::::1;7795:51:1::0;7862:18;;;7855:34;7768:18;;66098:88:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;66020:174:::0;:::o;64647:68::-;35158:13;:11;:13::i;:::-;64697:10:::1;:8;:10::i;6891:104::-:0;6947:13;6980:7;6973:14;;;;;:::i;11249:424::-;11342:4;4398:10;11342:4;11425:25;4398:10;11442:7;11425:9;:25::i;:::-;11398:52;;11489:15;11469:16;:35;;11461:85;;;;-1:-1:-1;;;11461:85:0;;8352:2:1;11461:85:0;;;8334:21:1;8391:2;8371:18;;;8364:30;8430:34;8410:18;;;8403:62;-1:-1:-1;;;8481:18:1;;;8474:35;8526:19;;11461:85:0;8150:401:1;11461:85:0;11574:60;11583:5;11590:7;11618:15;11599:16;:34;11574:8;:60::i;:::-;-1:-1:-1;11661:4:0;;11249:424;-1:-1:-1;;;;11249:424:0:o;68445:184::-;68502:4;35158:13;:11;:13::i;:::-;-1:-1:-1;;;;;68527:18:0;::::1;68519:65;;;;-1:-1:-1::0;;;68519:65:0::1;;;;;;;:::i;:::-;68602:19;:6;68616:4:::0;68602:13:::1;:19::i;59902:151::-:0;59981:4;60005:40;4398:10;60034:2;60038:6;60005:14;:40::i;68015:115::-;35158:13;:11;:13::i;:::-;68092:19:::1;:30:::0;;;::::1;;-1:-1:-1::0;;;68092:30:0::1;-1:-1:-1::0;;;;68092:30:0;;::::1;::::0;;;::::1;::::0;;68015:115::o;67903:104::-;35158:13;:11;:13::i;:::-;67977:11:::1;:22:::0;;;::::1;;-1:-1:-1::0;;;67977:22:0::1;-1:-1:-1::0;;;;67977:22:0;;::::1;::::0;;;::::1;::::0;;67903:104::o;68743:185::-;68796:7;68851:1;68833:15;:6;:13;:15::i;:::-;:19;;;;:::i;:::-;68824:5;:28;;68816:70;;;;-1:-1:-1;;;68816:70:0;;9161:2:1;68816:70:0;;;9143:21:1;9200:2;9180:18;;;9173:30;9239:31;9219:18;;;9212:59;9288:18;;68816:70:0;8959:353:1;68816:70:0;68904:16;:6;68914:5;68904:9;:16::i;65753:259::-;35158:13;:11;:13::i;:::-;65931:12:::1;::::0;;65815:17:::1;65931:12:::0;;;::::1;::::0;::::1;::::0;;;;65835:21:::1;::::0;65815:17;;4398:10;;65835:21;;65886:58:::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65867:77;;;65963:7;65955:49;;;::::0;-1:-1:-1;;;65955:49:0;;9943:2:1;65955:49:0::1;::::0;::::1;9925:21:1::0;9982:2;9962:18;;;9955:30;10021:31;10001:18;;;9994:59;10070:18;;65955:49:0::1;9741:353:1::0;67033:464:0;35158:13;:11;:13::i;:::-;67234:10:::1;:20:::0;;;67265:12:::1;:24:::0;;;67300:16:::1;:32:::0;;;67343:14:::1;:28:::0;;;67382:11:::1;:22:::0;;;67396:8;67360:11;67319:13;67430:18:::1;67280:9:::0;67247:7;67430:18:::1;:::i;:::-;:34;;;;:::i;:::-;:48;;;;:::i;:::-;:59;;;;:::i;:::-;67415:12;:74:::0;-1:-1:-1;;;;;67033:464:0:o;68256:181::-;68313:4;35158:13;:11;:13::i;:::-;-1:-1:-1;;;;;68338:18:0;::::1;68330:65;;;;-1:-1:-1::0;;;68330:65:0::1;;;;;;;:::i;:::-;68413:16;:6;68424:4:::0;68413:10:::1;:16::i;67505:263::-:0;35158:13;:11;:13::i;:::-;67660:9:::1;:22:::0;;-1:-1:-1;;;;;67660:22:0;;::::1;-1:-1:-1::0;;;;;;67660:22:0;;::::1;;::::0;;;67693:11:::1;:26:::0;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;67730:13:::1;:30:::0;;;;;::::1;::::0;::::1;;::::0;;67505:263::o;8552:151::-;-1:-1:-1;;;;;8668:18:0;;;8641:7;8668:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8552:151::o;68138:110::-;68192:4;68216:24;:6;68232:7;68216:15;:24::i;36178:201::-;35158:13;:11;:13::i;:::-;-1:-1:-1;;;;;36267:22:0;::::1;36259:73;;;::::0;-1:-1:-1;;;36259:73:0;;10301:2:1;36259:73:0::1;::::0;::::1;10283:21:1::0;10340:2;10320:18;;;10313:30;10379:34;10359:18;;;10352:62;-1:-1:-1;;;10430:18:1;;;10423:36;10476:19;;36259:73:0::1;10099:402:1::0;36259:73:0::1;36343:28;36362:8;36343:18;:28::i;35437:132::-:0;35345:6;;-1:-1:-1;;;;;35345:6:0;4398:10;35501:23;35493:68;;;;-1:-1:-1;;;35493:68:0;;10708:2:1;35493:68:0;;;10690:21:1;;;10727:18;;;10720:30;10786:34;10766:18;;;10759:62;10838:18;;35493:68:0;10506:356:1;46136:117:0;46199:7;46226:19;46234:3;41436:18;;41353:109;15204:380;-1:-1:-1;;;;;15340:19:0;;15332:68;;;;-1:-1:-1;;;15332:68:0;;11069:2:1;15332:68:0;;;11051:21:1;11108:2;11088:18;;;11081:30;11147:34;11127:18;;;11120:62;-1:-1:-1;;;11198:18:1;;;11191:34;11242:19;;15332:68:0;10867:400:1;15332:68:0;-1:-1:-1;;;;;15419:21:0;;15411:68;;;;-1:-1:-1;;;15411:68:0;;11474:2:1;15411:68:0;;;11456:21:1;11513:2;11493:18;;;11486:30;11552:34;11532:18;;;11525:62;-1:-1:-1;;;11603:18:1;;;11596:32;11645:19;;15411:68:0;11272:398:1;15411:68:0;-1:-1:-1;;;;;15492:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;15544:32;;160:25:1;;;15544:32:0;;133:18:1;15544:32:0;;;;;;;15204:380;;;:::o;15875:441::-;16010:24;16037:25;16047:5;16054:7;16037:9;:25::i;:::-;16010:52;;-1:-1:-1;;16077:16:0;:37;16073:236;;16159:6;16139:16;:26;;16131:68;;;;-1:-1:-1;;;16131:68:0;;11877:2:1;16131:68:0;;;11859:21:1;11916:2;11896:18;;;11889:30;11955:31;11935:18;;;11928:59;12004:18;;16131:68:0;11675:353:1;16131:68:0;16235:51;16244:5;16251:7;16279:6;16260:16;:25;16235:8;:51::i;:::-;15999:317;15875:441;;;:::o;60340:1210::-;60454:6;;60433:4;;-1:-1:-1;;;60454:6:0;;;;60450:101;;;60477:36;60487:6;60495:9;60506:6;60477:9;:36::i;:::-;-1:-1:-1;60535:4:0;60528:11;;60450:101;-1:-1:-1;;;;;60566:35:0;;;;;;:27;:35;;;;;;;;60561:112;;64790:10;;60618:43;;;;-1:-1:-1;;;60618:43:0;;12235:2:1;60618:43:0;;;12217:21:1;12274:2;12254:18;;;12247:30;-1:-1:-1;;;12293:18:1;;;12286:50;12353:18;;60618:43:0;12033:344:1;60618:43:0;-1:-1:-1;;;;;60708:19:0;;60685:18;60708:19;;;:11;:19;;;;;;;;60707:20;:47;;;;-1:-1:-1;;;;;;60732:22:0;;;;;;:11;:22;;;;;;;;60731:23;60707:47;60706:63;;;;-1:-1:-1;64790:10:0;;:15;;60759:10;60685:84;-1:-1:-1;60780:9:0;60820:6;60853:9;60898:14;60820:6;60898;:14::i;:::-;60894:283;;;60929:9;64870:10;;64860:7;:20;64900:9;;64891:6;:18;64931:11;;64920:8;:22;64968:15;;64953:12;:30;65007:13;;64994:10;:26;65042:11;;65031:8;:22;64821:240;60929:9;-1:-1:-1;60960:1:0;;-1:-1:-1;60984:9:0;;-1:-1:-1;61016:6:0;60894:283;;;61044:17;61051:9;61044:6;:17::i;:::-;61040:137;;;61078:10;65119:11;;65109:7;:21;65150:10;;65141:6;:19;65182:12;;65171:8;:23;65220:16;;-1:-1:-1;65205:31:0;65260:14;;-1:-1:-1;65247:27:0;65296:12;;-1:-1:-1;65285:23:0;65069:247;61078:10;61110:1;61103:8;;61040:137;;;61160:5;61144:21;;61040:137;61193:16;:14;:16::i;:::-;61189:59;;;61226:10;:8;:10::i;:::-;61260:22;61285:13;:48;;61327:6;61285:48;;;61301:23;61309:6;61317;61301:7;:23::i;:::-;61260:73;;61344:44;61354:6;61362:9;61373:14;61344:9;:44::i;:::-;61405:8;;61401:120;;61435:74;61441:5;61448;61455:6;61463:4;61469:22;:20;:22::i;:::-;61435:74;;;-1:-1:-1;;;;;12725:15:1;;;12707:34;;12777:15;;;;12772:2;12757:18;;12750:43;12809:18;;;12802:34;;;;12867:2;12852:18;;12845:34;12910:3;12895:19;;12888:35;61493:15:0;12687:3:1;12939:19;;12932:35;12656:3;12641:19;61435:74:0;;;;;;;61401:120;-1:-1:-1;61538:4:0;;60340:1210;-1:-1:-1;;;;;;;;60340:1210:0:o;30275:211::-;30419:58;;;-1:-1:-1;;;;;7813:32:1;;30419:58:0;;;7795:51:1;7862:18;;;;7855:34;;;30419:58:0;;;;;;;;;;7768:18:1;;;;30419:58:0;;;;;;;;-1:-1:-1;;;;;30419:58:0;-1:-1:-1;;;30419:58:0;;;30392:86;;30412:5;;30392:19;:86::i;:::-;30275:211;;;:::o;45311:152::-;45381:4;45405:50;45410:3;-1:-1:-1;;;;;45430:23:0;;45405:4;:50::i;36539:191::-;36632:6;;;-1:-1:-1;;;;;36649:17:0;;;-1:-1:-1;;;;;;36649:17:0;;;;;;;36682:40;;36632:6;;;36649:17;36632:6;;36682:40;;36613:16;;36682:40;36602:128;36539:191;:::o;61740:1784::-;57337:6;:13;;-1:-1:-1;;;;57337:13:0;-1:-1:-1;;;57337:13:0;;;61827:4:::1;-1:-1:-1::0;8064:18:0;;;;;;;;;;;61789:44:::1;;61844:55;61861:4;61876:10;61889:9;61844:8;:55::i;:::-;61912:23;61963:8;;61951:7;;61939:9;:19;;;;:::i;:::-;61938:34;;;;:::i;:::-;61912:60;;61983:21;62037:8;;62020:12;;62008:9;:24;;;;:::i;:::-;62007:39;;;;:::i;:::-;61983:63:::0;-1:-1:-1;62057:28:0::1;62070:15:::0;62057:28;::::1;:::i;:::-;::::0;-1:-1:-1;62096:26:0::1;62109:13:::0;62057:28;62096:26:::1;:::i;:::-;62159:16;::::0;;62173:1:::1;62159:16:::0;;;;;::::1;::::0;;62096:26;;-1:-1:-1;62135:21:0::1;::::0;62159:16;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;62159:16:0::1;62135:40;;62204:4;62186;62191:1;62186:7;;;;;;;;:::i;:::-;;;;;;:23;-1:-1:-1::0;;;;;62186:23:0::1;;;-1:-1:-1::0;;;;;62186:23:0::1;;;::::0;::::1;62238:4;62220;62225:1;62220:7;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;62220:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;62347:109:::1;::::0;-1:-1:-1;;;62347:109:0;;62256:12:::1;::::0;62311:21:::1;::::0;62347:10:::1;:61:::0;;::::1;::::0;::::1;::::0;:109:::1;::::0;62409:9;;62256:12;;62421:4;;62434::::1;::::0;62440:15:::1;::::0;62347:109:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;62343:173:::0;::::1;;62482:4;62472:14;;62343:173;62533:7;62528:47;;62557:7;;;;;;;;62528:47;62587;62605:4;58662:42;62618:15;62587:9;:47::i;:::-;62647:23;62673:37;62697:13:::0;62673:21:::1;:37;:::i;:::-;62647:63;;62721:25;62770:12;;62760:7;;62749:8;;:18;;;;:::i;:::-;:33;;;;:::i;:::-;62721:61;;62793:26;62852:17;62841:6;;62823:15;:24;;;;:::i;:::-;62822:48;;;;:::i;:::-;62793:77;;62881:28;62944:17;62931:8;;62913:15;:26;;;;:::i;:::-;62912:50;;;;:::i;:::-;62881:81:::0;-1:-1:-1;62973:30:0::1;62881:81:::0;63006:36:::1;63024:18:::0;63006:15;:36:::1;:::i;:::-;:59;;;;:::i;:::-;63094:9;::::0;63078:63:::1;::::0;62973:92;;-1:-1:-1;;;;;;63094:9:0::1;::::0;63118:18;;63078:63:::1;::::0;;;63118:18;63094:9;63078:63:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;63168:11:0::1;::::0;63152:67:::1;::::0;-1:-1:-1;;;;;63168:11:0;;::::1;::::0;-1:-1:-1;63194:20:0;;63152:67:::1;::::0;;;63194:20;63168:11;63152:67:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;63246:13:0::1;::::0;63230:71:::1;::::0;-1:-1:-1;;;;;63246:13:0;;::::1;::::0;-1:-1:-1;63274:22:0;;63230:71:::1;::::0;;;63274:22;63246:13;63230:71:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;63318:19:0::1;::::0;-1:-1:-1;;;63318:19:0;::::1;;;63314:62;::::0;-1:-1:-1;63314:62:0::1;;63354:10;:8;:10::i;:::-;63393:123;::::0;;14987:25:1;;;15043:2;15028:18;;15021:34;;;15071:18;;;15064:34;;;15129:2;15114:18;;15107:34;;;15172:3;15157:19;;15150:35;;;63500:15:0::1;15216:3:1::0;15201:19;;15194:35;63393:123:0::1;::::0;14974:3:1;14959:19;63393:123:0::1;;;;;;;61778:1746;;;;;;;;;;;57361:1;57373:6:::0;:14;;-1:-1:-1;;;;57373:14:0;;;61740:1784::o;45639:158::-;45712:4;45736:53;45744:3;-1:-1:-1;;;;;45764:23:0;;45736:7;:53::i;46607:158::-;46681:7;46732:22;46736:3;46748:5;46732:3;:22::i;45883:167::-;-1:-1:-1;;;;;46017:23:0;;45963:4;41235:19;;;:12;;;:19;;;;;;:24;;45987:55;41138:129;12143:816;-1:-1:-1;;;;;12274:18:0;;12266:68;;;;-1:-1:-1;;;12266:68:0;;15442:2:1;12266:68:0;;;15424:21:1;15481:2;15461:18;;;15454:30;15520:34;15500:18;;;15493:62;-1:-1:-1;;;15571:18:1;;;15564:35;15616:19;;12266:68:0;15240:401:1;12266:68:0;-1:-1:-1;;;;;12353:16:0;;12345:64;;;;-1:-1:-1;;;12345:64:0;;15848:2:1;12345:64:0;;;15830:21:1;15887:2;15867:18;;;15860:30;15926:34;15906:18;;;15899:62;-1:-1:-1;;;15977:18:1;;;15970:33;16020:19;;12345:64:0;15646:399:1;12345:64:0;-1:-1:-1;;;;;12495:15:0;;12473:19;12495:15;;;;;;;;;;;12529:21;;;;12521:72;;;;-1:-1:-1;;;12521:72:0;;16252:2:1;12521:72:0;;;16234:21:1;16291:2;16271:18;;;16264:30;16330:34;16310:18;;;16303:62;-1:-1:-1;;;16381:18:1;;;16374:36;16427:19;;12521:72:0;16050:402:1;12521:72:0;-1:-1:-1;;;;;12621:15:0;;;:9;:15;;;;;;;;;;;12639:20;;;12621:38;;12827:13;;;;;;;;;;:23;;;;;;12875:26;;160:25:1;;;12827:13:0;;12875:26;;133:18:1;12875:26:0;;;;;;;12914:37;30275:211;61558:174;61632:6;;61607:4;;-1:-1:-1;;;61632:6:0;;;;61631:7;:22;;;;-1:-1:-1;61642:11:0;;-1:-1:-1;;;61642:11:0;;;;61631:22;:36;;;;-1:-1:-1;64790:10:0;;:15;;61657:10;61631:68;;;;-1:-1:-1;61689:4:0;61698:1;8064:18;;;;;;;;;;;61671:28;61631:68;:93;;;;-1:-1:-1;61704:20:0;4398:10;68138:110;:::i;61704:20::-;61703:21;61624:100;;61558:174;:::o;65324:241::-;65391:7;65411:17;65453:14;;65441:8;;65432:6;:17;;;;:::i;:::-;65431:36;;;;:::i;:::-;65411:56;;65478:43;65488:6;65504:4;65511:9;65478;:43::i;:::-;65539:18;65548:9;65539:6;:18;:::i;:::-;65532:25;65324:241;-1:-1:-1;;;;65324:241:0:o;33318:716::-;33742:23;33768:69;33796:4;33768:69;;;;;;;;;;;;;;;;;33776:5;-1:-1:-1;;;;;33768:27:0;;;:69;;;;;:::i;:::-;33852:17;;33742:95;;-1:-1:-1;33852:21:0;33848:179;;33949:10;33938:30;;;;;;;;;;;;:::i;:::-;33930:85;;;;-1:-1:-1;;;33930:85:0;;16659:2:1;33930:85:0;;;16641:21:1;16698:2;16678:18;;;16671:30;16737:34;16717:18;;;16710:62;-1:-1:-1;;;16788:18:1;;;16781:40;16838:19;;33930:85:0;16457:406:1;39042:414:0;39105:4;41235:19;;;:12;;;:19;;;;;;39122:327;;-1:-1:-1;39165:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;39348:18;;39326:19;;;:12;;;:19;;;;;;:40;;;;39381:11;;39122:327;-1:-1:-1;39432:5:0;39425:12;;63532:735;63599:16;;;63613:1;63599:16;;;;;;;;63572:24;;63599:16;;;;;;;;;;-1:-1:-1;63599:16:0;63572:43;;63647:4;63626:7;63634:1;63626:10;;;;;;;;:::i;:::-;;;;;;:26;-1:-1:-1;;;;;63626:26:0;;;-1:-1:-1;;;;;63626:26:0;;;;;63684:4;63663:7;63671:1;63663:10;;;;;;;;:::i;:::-;-1:-1:-1;;;;;63663:26:0;;;;:10;;;;;;;;;;:26;63742:4;63702:19;8064:18;;;;;;;;;;;;63774:15;63788:1;8064:18;63774:15;:::i;:::-;63759:30;;63810:4;63803;:11;63800:23;;;63816:7;;;63532:735::o;63800:23::-;63930:108;;-1:-1:-1;;;63930:108:0;;63861:21;;63835:23;;-1:-1:-1;;;;;63930:10:0;:61;;;;:108;;63992:4;;63835:23;;64000:7;;64016:4;;64022:15;;63930:108;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63926:162;;;-1:-1:-1;64063:4:0;63926:162;64105:7;64100:47;;64129:7;;;;;63532:735::o;64100:47::-;64159:17;64179:39;64203:15;64179:21;:39;:::i;:::-;64159:59;;64229:30;64243:4;64249:9;64229:13;:30::i;:::-;63561:706;;;;;;63532:735::o;39632:1420::-;39698:4;39837:19;;;:12;;;:19;;;;;;39873:15;;39869:1176;;40248:21;40272:14;40285:1;40272:10;:14;:::i;:::-;40321:18;;40248:38;;-1:-1:-1;40301:17:0;;40321:22;;40342:1;;40321:22;:::i;:::-;40301:42;;40377:13;40364:9;:26;40360:405;;40411:17;40431:3;:11;;40443:9;40431:22;;;;;;;;:::i;:::-;;;;;;;;;40411:42;;40585:9;40556:3;:11;;40568:13;40556:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;40670:23;;;:12;;;:23;;;;;:36;;;40360:405;40846:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;40941:3;:12;;:19;40954:5;40941:19;;;;;;;;;;;40934:26;;;40984:4;40977:11;;;;;;;39869:1176;41028:5;41021:12;;;;;41816:120;41883:7;41910:3;:11;;41922:5;41910:18;;;;;;;;:::i;:::-;;;;;;;;;41903:25;;41816:120;;;;:::o;24127:229::-;24264:12;24296:52;24318:6;24326:4;24332:1;24335:12;24296:21;:52::i;64275:364::-;64358:57;64375:4;64390:10;64403:11;64358:8;:57::i;:::-;64430:107;;-1:-1:-1;;;64430:107:0;;64483:4;64430:107;;;17341:34:1;17391:18;;;17384:34;;;64503:1:0;17434:18:1;;;17427:34;;;17477:18;;;17470:34;;;17520:19;;;17513:44;64521:15:0;17573:19:1;;;17566:35;64430:10:0;-1:-1:-1;;;;;64430:26:0;;;;64464:9;;17275:19:1;;64430:107:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64430:107:0;;;;;;;;-1:-1:-1;;64430:107:0;;;;;;;;;;;;:::i;:::-;;;64426:206;;;-1:-1:-1;;64558:53:0;;;18125:25:1;;;18181:2;18166:18;;18159:34;;;64595:15:0;18209:18:1;;;18202:34;64558:53:0;;;;-1:-1:-1;64558:53:0;;;;18113:2:1;64558:53:0;;;64275:364;;:::o;25247:455::-;25417:12;25475:5;25450:21;:30;;25442:81;;;;-1:-1:-1;;;25442:81:0;;18449:2:1;25442:81:0;;;18431:21:1;18488:2;18468:18;;;18461:30;18527:34;18507:18;;;18500:62;-1:-1:-1;;;18578:18:1;;;18571:36;18624:19;;25442:81:0;18247:402:1;25442:81:0;25535:12;25549:23;25576:6;-1:-1:-1;;;;;25576:11:0;25595:5;25602:4;25576:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25534:73;;;;25625:69;25652:6;25660:7;25669:10;25681:12;25625:26;:69::i;:::-;25618:76;25247:455;-1:-1:-1;;;;;;;25247:455:0:o;27820:644::-;28005:12;28034:7;28030:427;;;28062:10;:17;28083:1;28062:22;28058:290;;-1:-1:-1;;;;;21665:19:0;;;28272:60;;;;-1:-1:-1;;;28272:60:0;;18856:2:1;28272:60:0;;;18838:21:1;18895:2;18875:18;;;18868:30;18934:31;18914:18;;;18907:59;18983:18;;28272:60:0;18654:353:1;28272:60:0;-1:-1:-1;28369:10:0;28362:17;;28030:427;28412:33;28420:10;28432:12;29167:17;;:21;29163:388;;29399:10;29393:17;29456:15;29443:10;29439:2;29435:19;29428:44;29163:388;29526:12;29519:20;;-1:-1:-1;;;29519:20:0;;;;;;;;:::i;196:250:1:-;281:1;291:113;305:6;302:1;299:13;291:113;;;381:11;;;375:18;362:11;;;355:39;327:2;320:10;291:113;;;-1:-1:-1;;438:1:1;420:16;;413:27;196:250::o;451:396::-;600:2;589:9;582:21;563:4;632:6;626:13;675:6;670:2;659:9;655:18;648:34;691:79;763:6;758:2;747:9;743:18;738:2;730:6;726:15;691:79;:::i;:::-;831:2;810:15;-1:-1:-1;;806:29:1;791:45;;;;838:2;787:54;;451:396;-1:-1:-1;;451:396:1:o;852:131::-;-1:-1:-1;;;;;927:31:1;;917:42;;907:70;;973:1;970;963:12;988:315;1056:6;1064;1117:2;1105:9;1096:7;1092:23;1088:32;1085:52;;;1133:1;1130;1123:12;1085:52;1172:9;1159:23;1191:31;1216:5;1191:31;:::i;:::-;1241:5;1293:2;1278:18;;;;1265:32;;-1:-1:-1;;;988:315:1:o;1708:456::-;1785:6;1793;1801;1854:2;1842:9;1833:7;1829:23;1825:32;1822:52;;;1870:1;1867;1860:12;1822:52;1909:9;1896:23;1928:31;1953:5;1928:31;:::i;:::-;1978:5;-1:-1:-1;2035:2:1;2020:18;;2007:32;2048:33;2007:32;2048:33;:::i;:::-;1708:456;;2100:7;;-1:-1:-1;;;2154:2:1;2139:18;;;;2126:32;;1708:456::o;2358:247::-;2417:6;2470:2;2458:9;2449:7;2445:23;2441:32;2438:52;;;2486:1;2483;2476:12;2438:52;2525:9;2512:23;2544:31;2569:5;2544:31;:::i;2610:454::-;2705:6;2713;2721;2729;2737;2790:3;2778:9;2769:7;2765:23;2761:33;2758:53;;;2807:1;2804;2797:12;2758:53;-1:-1:-1;;2830:23:1;;;2900:2;2885:18;;2872:32;;-1:-1:-1;2951:2:1;2936:18;;2923:32;;3002:2;2987:18;;2974:32;;-1:-1:-1;3053:3:1;3038:19;3025:33;;-1:-1:-1;2610:454:1;-1:-1:-1;2610:454:1:o;3069:118::-;3155:5;3148:13;3141:21;3134:5;3131:32;3121:60;;3177:1;3174;3167:12;3192:382;3257:6;3265;3318:2;3306:9;3297:7;3293:23;3289:32;3286:52;;;3334:1;3331;3324:12;3286:52;3373:9;3360:23;3392:31;3417:5;3392:31;:::i;:::-;3442:5;-1:-1:-1;3499:2:1;3484:18;;3471:32;3512:30;3471:32;3512:30;:::i;:::-;3561:7;3551:17;;;3192:382;;;;;:::o;3579:241::-;3635:6;3688:2;3676:9;3667:7;3663:23;3659:32;3656:52;;;3704:1;3701;3694:12;3656:52;3743:9;3730:23;3762:28;3784:5;3762:28;:::i;4047:180::-;4106:6;4159:2;4147:9;4138:7;4134:23;4130:32;4127:52;;;4175:1;4172;4165:12;4127:52;-1:-1:-1;4198:23:1;;4047:180;-1:-1:-1;4047:180:1:o;4467:529::-;4544:6;4552;4560;4613:2;4601:9;4592:7;4588:23;4584:32;4581:52;;;4629:1;4626;4619:12;4581:52;4668:9;4655:23;4687:31;4712:5;4687:31;:::i;:::-;4737:5;-1:-1:-1;4794:2:1;4779:18;;4766:32;4807:33;4766:32;4807:33;:::i;:::-;4859:7;-1:-1:-1;4918:2:1;4903:18;;4890:32;4931:33;4890:32;4931:33;:::i;:::-;4983:7;4973:17;;;4467:529;;;;;:::o;5001:388::-;5069:6;5077;5130:2;5118:9;5109:7;5105:23;5101:32;5098:52;;;5146:1;5143;5136:12;5098:52;5185:9;5172:23;5204:31;5229:5;5204:31;:::i;:::-;5254:5;-1:-1:-1;5311:2:1;5296:18;;5283:32;5324:33;5283:32;5324:33;:::i;5739:380::-;5818:1;5814:12;;;;5861;;;5882:61;;5936:4;5928:6;5924:17;5914:27;;5882:61;5989:2;5981:6;5978:14;5958:18;5955:38;5952:161;;6035:10;6030:3;6026:20;6023:1;6016:31;6070:4;6067:1;6060:15;6098:4;6095:1;6088:15;5952:161;;5739:380;;;:::o;6124:127::-;6185:10;6180:3;6176:20;6173:1;6166:31;6216:4;6213:1;6206:15;6240:4;6237:1;6230:15;6256:128;6323:9;;;6344:11;;;6341:37;;;6358:18;;:::i;6389:125::-;6454:9;;;6475:10;;;6472:36;;;6488:18;;:::i;6519:184::-;6589:6;6642:2;6630:9;6621:7;6617:23;6613:32;6610:52;;;6658:1;6655;6648:12;6610:52;-1:-1:-1;6681:16:1;;6519:184;-1:-1:-1;6519:184:1:o;7365:251::-;7435:6;7488:2;7476:9;7467:7;7463:23;7459:32;7456:52;;;7504:1;7501;7494:12;7456:52;7536:9;7530:16;7555:31;7580:5;7555:31;:::i;7900:245::-;7967:6;8020:2;8008:9;7999:7;7995:23;7991:32;7988:52;;;8036:1;8033;8026:12;7988:52;8068:9;8062:16;8087:28;8109:5;8087:28;:::i;8556:398::-;8758:2;8740:21;;;8797:2;8777:18;;;8770:30;8836:34;8831:2;8816:18;;8809:62;-1:-1:-1;;;8902:2:1;8887:18;;8880:32;8944:3;8929:19;;8556:398::o;9449:287::-;9578:3;9616:6;9610:13;9632:66;9691:6;9686:3;9679:4;9671:6;9667:17;9632:66;:::i;:::-;9714:16;;;;;9449:287;-1:-1:-1;;9449:287:1:o;12978:168::-;13051:9;;;13082;;13099:15;;;13093:22;;13079:37;13069:71;;13120:18;;:::i;13151:217::-;13191:1;13217;13207:132;;13261:10;13256:3;13252:20;13249:1;13242:31;13296:4;13293:1;13286:15;13324:4;13321:1;13314:15;13207:132;-1:-1:-1;13353:9:1;;13151:217::o;13373:127::-;13434:10;13429:3;13425:20;13422:1;13415:31;13465:4;13462:1;13455:15;13489:4;13486:1;13479:15;13505:980;13767:4;13815:3;13804:9;13800:19;13846:6;13835:9;13828:25;13872:2;13910:6;13905:2;13894:9;13890:18;13883:34;13953:3;13948:2;13937:9;13933:18;13926:31;13977:6;14012;14006:13;14043:6;14035;14028:22;14081:3;14070:9;14066:19;14059:26;;14120:2;14112:6;14108:15;14094:29;;14141:1;14151:195;14165:6;14162:1;14159:13;14151:195;;;14230:13;;-1:-1:-1;;;;;14226:39:1;14214:52;;14321:15;;;;14286:12;;;;14262:1;14180:9;14151:195;;;-1:-1:-1;;;;;;;14402:32:1;;;;14397:2;14382:18;;14375:60;-1:-1:-1;;;14466:3:1;14451:19;14444:35;14363:3;13505:980;-1:-1:-1;;;13505:980:1:o;16868:127::-;16929:10;16924:3;16920:20;16917:1;16910:31;16960:4;16957:1;16950:15;16984:4;16981:1;16974:15;17612:306;17700:6;17708;17716;17769:2;17757:9;17748:7;17744:23;17740:32;17737:52;;;17785:1;17782;17775:12;17737:52;17814:9;17808:16;17798:26;;17864:2;17853:9;17849:18;17843:25;17833:35;;17908:2;17897:9;17893:18;17887:25;17877:35;;17612:306;;;;;:::o

Swarm Source

ipfs://fde2863c3abe006ae3db718c5298fe115e840c597303907b3da8e677f5368c4a

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services