Token

Zypto Token (ZYPTO)

ERC-20

Payments

Overview

Max Total Supply

1,000,000,000 ZYPTO

Holders

4,944 ( -0.020%)

Market

Price

$0.01 @ 0.000004 ETH (-3.05%)

Onchain Market Cap

$13,339,150.00

Circulating Supply Market Cap

$11,848,827.00

Other Info

Token Contract (WITH 18 Decimals)

0x7a65cb87f596caf31a4932f074c59c0592be77d7

Filtered by Token Holder

0x0e1876A1a145108F6a263132E69d506d8d0B4702

Balance

329,624.07 ZYPTO

Value

$4,396.90 ( ~1.2926 Eth) [0.0330%]

0x0e1876A1a145108F6a263132E69d506d8d0B4702

OVERVIEW

Zypto makes using crypto as easy as your go-to banking app or payment gateway. The Zypto Token community and the Zypto company work together to take crypto mainstream.

Market

Volume (24H)	:	$99,186.00
Market Capitalization	:	$11,848,827.00
Circulating Supply	:	895,156,207.00 ZYPTO
Market Data Source: Coinmarketcap

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ZyptoToken

Compiler Version

v0.8.24+commit.e11b9ed9

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-02-19
*/

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

// File @openzeppelin/contracts/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

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

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

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


// File @openzeppelin/contracts/access/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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/interfaces/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC20/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

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

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

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


// File @openzeppelin/contracts/token/ERC20/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)


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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

        emit Transfer(from, to, value);
    }

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)


/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

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

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


// File @openzeppelin/contracts/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)


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

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)


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

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

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

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

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

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

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

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

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

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

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

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


// File contracts/lib/Rescuable.sol

// Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.23;




abstract contract Rescuable is Ownable {
    using SafeERC20 for IERC20;
    using Address for address payable;

    function rescueERC20(IERC20 _token) external onlyOwner {
        _token.safeTransfer(msg.sender, _token.balanceOf(address(this)));
    }
    function rescueETH() external onlyOwner {
        payable(_msgSender()).sendValue(address(this).balance);
    }

}


// File contracts/interfaces/IUniswapV2.sol

// Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.23;

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

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

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

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

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

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

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

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}


// File contracts/lib/Percentages.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.23;

library Percentages {
    // Get value of a percent of a number
    function calcPortionFromBasisPoints(uint256 _amount, uint256 _basisPoints) internal pure returns(uint256) {
        if(_basisPoints == 0 || _amount == 0) {
            return 0;
        } else {
            uint256 _portion = (_amount * _basisPoints) / 10000;
            return _portion;
        }
    }

    // Get basis points (percentage) of _portion relative to _amount
    function calcBasisPoints(uint256 _amount, uint256  _portion) internal pure returns(uint256) {
        if(_portion == 0 || _amount == 0) {
            return 0;
        } else {
            uint256 _basisPoints = (_portion * 10000) / _amount;
            return _basisPoints;
        }
    }
}


// File contracts/ZyptoToken.sol

// Original license: SPDX_License_Identifier: MIT



// Contract notes:
// * SafeMath is generally not needed anymore since Solidity 0.8.0
// * All percentages are expressed in "basis points" (100bps = 1%)

contract ZyptoToken is ERC20, Rescuable {
    using Percentages for uint256;
    using SafeERC20 for IERC20;

    IUniswapV2Router02 public immutable _uniswapV2Router;
    address public immutable _WETH;
    address public immutable _uniswapV2Pair;
    
    // Fees
    uint256 public constant MAX_TOTAL_FEE = 400; // 400 basis points (4%)
    uint256 public _buyFeeLiquidity;
    uint256 public _buyFeeMarketing;
    uint256 public _buyFeeTotal;
    uint256 public _sellFeeLiquidity;
    uint256 public _sellFeeMarketing;
    uint256 public _sellFeeTotal;
    uint256 public _pendingMarketingValue;
    address payable public _marketingWallet;
    bool public _isOpenForTrading = false;
    mapping (address => bool) public _isExcludedFromFees;
    mapping (address => bool) public _isAutomatedMarketMakerPair;

    // SwapAndLiquify
    bool private _inSwapAndLiquify;
    bool public _swapAndLiquifyEnabled = true;
    uint256 public _swapTokensAtAmount = 100_000 * 1e18;

    event ExcludeFromFees(address indexed account, bool isExcluded);
    event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
    event SwapAndLiquifyEnabledUpdated(bool enabled);
    event SwapAndLiquify(uint256 tokensIntoLiqudity, uint256 ethReceived);

    constructor(address tokenOwner, address router, address marketing) ERC20("Zypto Token", "ZYPTO") Ownable(msg.sender) {
        _uniswapV2Router = IUniswapV2Router02(router); // Uniswap: 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        _marketingWallet = payable(marketing); // Default: 0xdC7DA1Cbb010087a1F8E95676FcB3cFf4aEacB26
        _WETH = _uniswapV2Router.WETH();
        
        // Create a uniswap pair for this token
        _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _WETH);
        _isAutomatedMarketMakerPair[_uniswapV2Pair] = true;

        excludeFromFees(tokenOwner, true);
        excludeFromFees(_marketingWallet, true);
        excludeFromFees(address(this), true);

        _mint(tokenOwner, 1_000_000_000 * 1e18);

        // Default fees
        setBuyFee(200, 200);
        setSellFee(200, 200);

        if (owner() != tokenOwner) {
            transferOwnership(tokenOwner);
        }
    }

    receive() external payable {
  	}    

    modifier lockTheSwap {
        _inSwapAndLiquify = true;
        _;
        _inSwapAndLiquify = false;
    }

    modifier onlyOpenForTrading(address from, address to) {
        require(_isOpenForTrading || _isExcludedFromFees[from] || _isExcludedFromFees[to], "Not open for trading yet");
        _;
    }

    //
    // Management functions
    //
    function openTrade() external onlyOwner {
        _isOpenForTrading = true;
    }
    function setSwapAmont(uint256 swapTokensAtAmount) public onlyOwner {
        _swapTokensAtAmount = swapTokensAtAmount;
    }
    function setSwapAndLiquifyEnabled(bool enabled) public onlyOwner {
        _swapAndLiquifyEnabled = enabled;
        emit SwapAndLiquifyEnabledUpdated(enabled);
    }
    function setBuyFee(uint256 liquidityFee, uint256 marketingFee) public onlyOwner {
        _buyFeeLiquidity = liquidityFee;
        _buyFeeMarketing = marketingFee;
        _buyFeeTotal = _buyFeeLiquidity + _buyFeeMarketing; // total fee for buys
        require(_buyFeeTotal <= MAX_TOTAL_FEE, "buyFeeTotal is too high");
    }
    function setSellFee(uint256 liquidityFee, uint256 marketingFee) public onlyOwner {
        _sellFeeLiquidity = liquidityFee;
        _sellFeeMarketing = marketingFee;
        _sellFeeTotal = _sellFeeLiquidity + _sellFeeMarketing; // total fee for sells
        require(_sellFeeTotal <= MAX_TOTAL_FEE, "sellFeeTotal is too high");
    }
    function excludeFromFees(address account, bool excluded) public onlyOwner {
        require(_isExcludedFromFees[account] != excluded, "Account is already the value of 'excluded'");
        _isExcludedFromFees[account] = excluded;

        emit ExcludeFromFees(account, excluded);
    }
    function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
        for(uint256 i = 0; i < accounts.length; i++) {
            _isExcludedFromFees[accounts[i]] = excluded;
        }

        emit ExcludeMultipleAccountsFromFees(accounts, excluded);
    }
    function setMarketingWallet(address account) public onlyOwner {
        require(_marketingWallet != account, "Marketing wallet is the same");
        _marketingWallet = payable(account);
    }
    function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
        require(pair != _uniswapV2Pair, "The Uniswap pair cannot be removed from _isAutomatedMarketMakerPair");
        require(_isAutomatedMarketMakerPair[pair] != value, "Pair already has that value");

        _isAutomatedMarketMakerPair[pair] = value;
    }
    // Anyone can trigger swapAndLiquify at any time
    function swapAndLiquifyNow() public {
        uint256 contractTokenBalance = balanceOf(address(this));
        if (contractTokenBalance > 0) {
            swapAndLiquify(contractTokenBalance);
        }
    }

    //
    // Internal functions
    //
    function swapTokensForETH(uint256 tokenAmount, address to) private {
        // generate the uniswap pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _WETH;

        if(allowance(address(this), address(_uniswapV2Router)) < tokenAmount) {
          _approve(address(this), address(_uniswapV2Router), type(uint256).max);
        }

        // make the swap
        _uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            to,
            block.timestamp
        );
    }    

    function swapAndSendETHToMarketing(uint256 tokenAmount) private {
        swapTokensForETH(tokenAmount, _marketingWallet);
    }

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        // add the liquidity
        _uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            owner(),
            block.timestamp
        );
    }

    function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
        if (_pendingMarketingValue > 0) {
            // Send marketing tokens
            uint256 marketingValue = _pendingMarketingValue > contractTokenBalance ? contractTokenBalance : _pendingMarketingValue;
            swapAndSendETHToMarketing(marketingValue);
            contractTokenBalance = balanceOf(address(this));
            _pendingMarketingValue = 0;
        }

        // Note that all integer division rounds DOWN to the nearest integer
        uint256 tokensToAddLiquidityWith = contractTokenBalance / 2;
        
        // swap the remaining to ETH
        uint256 toSwap = contractTokenBalance-tokensToAddLiquidityWith;
        
        // capture the contract's current ETH balance.
        // this is so that we can capture exactly the amount of ETH that the
        // swap creates, and not make the liquidity event include any ETH that
        // has been manually sent to the contract
        uint256 initialBalance = address(this).balance;

        // swap tokens for ETH
        swapTokensForETH(toSwap, address(this));

        // ETH to use for liquidity add
        uint256 ethToAddLiquidityWith = address(this).balance-initialBalance;

        // add liquidity to uniswap
        addLiquidity(tokensToAddLiquidityWith, ethToAddLiquidityWith);
        
        emit SwapAndLiquify(tokensToAddLiquidityWith, ethToAddLiquidityWith);
    }
    function getFeesForTrade(address from) internal view returns (uint256 liquidityFee, uint256 marketingFee, uint256 totalFee) {
        if (_isAutomatedMarketMakerPair[from]) {
            liquidityFee = _buyFeeLiquidity;
            marketingFee = _buyFeeMarketing;
            totalFee = _buyFeeTotal;
        } else {
            liquidityFee = _sellFeeLiquidity;
            marketingFee = _sellFeeMarketing;
            totalFee = _sellFeeTotal;
        }
    }
    function isTrade(address from, address to) internal view returns (bool) {
        return _isAutomatedMarketMakerPair[from] || _isAutomatedMarketMakerPair[to];
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal override {
        if (!isTrade(from, to) || _isExcludedFromFees[from] || _isExcludedFromFees[to]) {
            super._update(from, to, value);
        } else {
            _trade(from, to, value);
        }
    }

    // Called only when the operation is a "trade" with fees (buy, sell, add liquidity, remove liquidity)
    function _trade(address from, address to, uint256 value) internal onlyOpenForTrading(from, to) {
        (uint256 liquidityFee, uint256 marketingFee, uint256 totalFee) = getFeesForTrade(from);

        if (totalFee > 0) {
            uint256 liquidityValue = value.calcPortionFromBasisPoints(liquidityFee);
            uint256 marketingValue = value.calcPortionFromBasisPoints(marketingFee);
            uint256 totalFeeValue = liquidityValue + marketingValue;
            value = value - totalFeeValue;
            super._update(from, address(this), totalFeeValue);
            _pendingMarketingValue += marketingValue;
        }
    	uint256 contractTokenBalance = balanceOf(address(this));
        bool overMinTokenBalance = contractTokenBalance >= _swapTokensAtAmount;
        if(
            overMinTokenBalance &&
            !_inSwapAndLiquify &&
            _isAutomatedMarketMakerPair[to] &&
            _swapAndLiquifyEnabled
        ) {
            swapAndLiquify(contractTokenBalance);
        }

        super._update(from, to, value);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"tokenOwner","type":"address"},{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"marketing","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"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":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"accounts","type":"address[]"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeMultipleAccountsFromFees","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":"tokensIntoLiqudity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"}],"name":"SwapAndLiquify","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"SwapAndLiquifyEnabledUpdated","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":"MAX_TOTAL_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_buyFeeLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_buyFeeMarketing","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_buyFeeTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isAutomatedMarketMakerPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_isOpenForTrading","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_marketingWallet","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_pendingMarketingValue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_sellFeeLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_sellFeeMarketing","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_sellFeeTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_swapAndLiquifyEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","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":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeMultipleAccountsFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openTrade","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"}],"name":"rescueERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rescueETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"liquidityFee","type":"uint256"},{"internalType":"uint256","name":"marketingFee","type":"uint256"}],"name":"setBuyFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"setMarketingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"liquidityFee","type":"uint256"},{"internalType":"uint256","name":"marketingFee","type":"uint256"}],"name":"setSellFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"swapTokensAtAmount","type":"uint256"}],"name":"setSwapAmont","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setSwapAndLiquifyEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapAndLiquifyNow","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":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

00000000000000000000000086a0985acba4ec2be144ee23b0147633be6c0f590000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d0000000000000000000000007ffa6cbe2516b0c15966f0da27261ffd0d9a8651

-----Decoded View---------------
Arg [0] : tokenOwner (address): 0x86A0985acba4eC2BE144ee23b0147633bE6C0F59
Arg [1] : router (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [2] : marketing (address): 0x7fFa6CBe2516B0c15966f0DA27261ffd0d9a8651

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000086a0985acba4ec2be144ee23b0147633be6c0f59
Arg [1] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [2] : 0000000000000000000000007ffa6cbe2516b0c15966f0da27261ffd0d9a8651

Deployed Bytecode Sourcemap

49576:10394:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16702:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18995:190;;;;;;;;;;-1:-1:-1;18995:190:0;;;;;:::i;:::-;;:::i;:::-;;;1291:14:1;;1284:22;1266:41;;1254:2;1239:18;18995:190:0;1126:187:1;50153:37:0;;;;;;;;;;;;;;;;;;;1464:25:1;;;1452:2;1437:18;50153:37:0;1318:177:1;17804:99:0;;;;;;;;;;-1:-1:-1;17883:12:0;;17804:99;;50040:32;;;;;;;;;;;;;;;;42673:113;;;;;;;;;;;;;:::i;:::-;;19763:249;;;;;;;;;;-1:-1:-1;19763:249:0;;;;;:::i;:::-;;:::i;50523:51::-;;;;;;;;;;;;;;;;17655:84;;;;;;;;;;-1:-1:-1;17655:84:0;;17729:2;2103:36:1;;2091:2;2076:18;17655:84:0;1961:184:1;49694:52:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2341:32:1;;;2323:51;;2311:2;2296:18;49694:52:0;2150:230:1;49930:31:0;;;;;;;;;;;;;;;;53959:195;;;;;;;;;;-1:-1:-1;53959:195:0;;;;;:::i;:::-;;:::i;49968:31::-;;;;;;;;;;;;;;;;53007:340;;;;;;;;;;-1:-1:-1;53007:340:0;;;;;:::i;:::-;;:::i;17966:118::-;;;;;;;;;;-1:-1:-1;17966:118:0;;;;;:::i;:::-;-1:-1:-1;;;;;18058:18:0;18031:7;18058:18;;;;;;;;;;;;17966:118;3475:103;;;;;;;;;;;;;:::i;54568:213::-;;;;;;;;;;;;;:::i;49855:43::-;;;;;;;;;;;;49895:3;49855:43;;2800:87;;;;;;;;;;-1:-1:-1;2873:6:0;;-1:-1:-1;;;;;2873:6:0;2800:87;;16912:95;;;;;;;;;;;;;:::i;50197:39::-;;;;;;;;;;-1:-1:-1;50197:39:0;;;;-1:-1:-1;;;;;50197:39:0;;;54160:348;;;;;;;;;;-1:-1:-1;54160:348:0;;;;;:::i;:::-;;:::i;49790:39::-;;;;;;;;;;;;;;;18289:182;;;;;;;;;;-1:-1:-1;18289:182:0;;;;;:::i;:::-;;:::i;52363:126::-;;;;;;;;;;-1:-1:-1;52363:126:0;;;;;:::i;:::-;;:::i;50118:28::-;;;;;;;;;;;;;;;;53353:290;;;;;;;;;;-1:-1:-1;53353:290:0;;;;;:::i;:::-;;:::i;53649:304::-;;;;;;;;;;-1:-1:-1;53649:304:0;;;;;:::i;:::-;;:::i;52495:169::-;;;;;;;;;;-1:-1:-1;52495:169:0;;;;;:::i;:::-;;:::i;50475:41::-;;;;;;;;;;-1:-1:-1;50475:41:0;;;;;;;;;;;50243:37;;;;;;;;;;-1:-1:-1;50243:37:0;;;;-1:-1:-1;;;50243:37:0;;;;;;50006:27;;;;;;;;;;;;;;;;42529:138;;;;;;;;;;-1:-1:-1;42529:138:0;;;;;:::i;:::-;;:::i;18534:142::-;;;;;;;;;;-1:-1:-1;18534:142:0;;;;;:::i;:::-;;:::i;49753:30::-;;;;;;;;;;;;;;;50287:52;;;;;;;;;;-1:-1:-1;50287:52:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;50079:32;;;;;;;;;;;;;;;;50346:60;;;;;;;;;;-1:-1:-1;50346:60:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;3733:220;;;;;;;;;;-1:-1:-1;3733:220:0;;;;;:::i;:::-;;:::i;52670:331::-;;;;;;;;;;-1:-1:-1;52670:331:0;;;;;:::i;:::-;;:::i;52274:83::-;;;;;;;;;;;;;:::i;16702:91::-;16747:13;16780:5;16773:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16702:91;:::o;18995:190::-;19068:4;862:10;19124:31;862:10;19140:7;19149:5;19124:8;:31::i;:::-;19173:4;19166:11;;;18995:190;;;;;:::o;42673:113::-;2686:13;:11;:13::i;:::-;42724:54:::1;862:10:::0;42756:21:::1;42724:31;:54::i;:::-;42673:113::o:0;19763:249::-;19850:4;862:10;19908:37;19924:4;862:10;19939:5;19908:15;:37::i;:::-;19956:26;19966:4;19972:2;19976:5;19956:9;:26::i;:::-;20000:4;19993:11;;;19763:249;;;;;;:::o;53959:195::-;2686:13;:11;:13::i;:::-;54040:16:::1;::::0;-1:-1:-1;;;;;54040:27:0;;::::1;:16:::0;::::1;:27:::0;54032:68:::1;;;::::0;-1:-1:-1;;;54032:68:0;;6264:2:1;54032:68:0::1;::::0;::::1;6246:21:1::0;6303:2;6283:18;;;6276:30;6342;6322:18;;;6315:58;6390:18;;54032:68:0::1;;;;;;;;;54111:16;:35:::0;;-1:-1:-1;;;;;;54111:35:0::1;-1:-1:-1::0;;;;;54111:35:0;;;::::1;::::0;;;::::1;::::0;;53959:195::o;53007:340::-;2686:13;:11;:13::i;:::-;53099:17:::1;:32:::0;;;53142:17:::1;:32:::0;;;53201:37:::1;53162:12:::0;53119;53201:37:::1;:::i;:::-;53185:13;:53:::0;;;49895:3:::1;-1:-1:-1::0;53280:30:0::1;53272:67;;;::::0;-1:-1:-1;;;53272:67:0;;6883:2:1;53272:67:0::1;::::0;::::1;6865:21:1::0;6922:2;6902:18;;;6895:30;6961:26;6941:18;;;6934:54;7005:18;;53272:67:0::1;6681:348:1::0;53272:67:0::1;53007:340:::0;;:::o;3475:103::-;2686:13;:11;:13::i;:::-;3540:30:::1;3567:1;3540:18;:30::i;54568:213::-:0;54664:4;54615:28;18058:18;;;;;;;;;;;54685:24;;54681:93;;54726:36;54741:20;54726:14;:36::i;:::-;54604:177;54568:213::o;16912:95::-;16959:13;16992:7;16985:14;;;;;:::i;54160:348::-;2686:13;:11;:13::i;:::-;54267:14:::1;-1:-1:-1::0;;;;;54259:22:0::1;:4;-1:-1:-1::0;;;;;54259:22:0::1;::::0;54251:102:::1;;;::::0;-1:-1:-1;;;54251:102:0;;7236:2:1;54251:102:0::1;::::0;::::1;7218:21:1::0;7275:2;7255:18;;;7248:30;7314:34;7294:18;;;7287:62;7385:34;7365:18;;;7358:62;-1:-1:-1;;;7436:19:1;;;7429:34;7480:19;;54251:102:0::1;7034:471:1::0;54251:102:0::1;-1:-1:-1::0;;;;;54372:33:0;::::1;;::::0;;;:27:::1;:33;::::0;;;;;:42;::::1;;:33;::::0;;::::1;:42;;::::0;54364:82:::1;;;::::0;-1:-1:-1;;;54364:82:0;;7712:2:1;54364:82:0::1;::::0;::::1;7694:21:1::0;7751:2;7731:18;;;7724:30;7790:29;7770:18;;;7763:57;7837:18;;54364:82:0::1;7510:351:1::0;54364:82:0::1;-1:-1:-1::0;;;;;54459:33:0;;;::::1;;::::0;;;:27:::1;:33;::::0;;;;:41;;-1:-1:-1;;54459:41:0::1;::::0;::::1;;::::0;;;::::1;::::0;;54160:348::o;18289:182::-;18358:4;862:10;18414:27;862:10;18431:2;18435:5;18414:9;:27::i;52363:126::-;2686:13;:11;:13::i;:::-;52441:19:::1;:40:::0;52363:126::o;53353:290::-;2686:13;:11;:13::i;:::-;-1:-1:-1;;;;;53446:28:0;::::1;;::::0;;;:19:::1;:28;::::0;;;;;:40;::::1;;:28;::::0;;::::1;:40;;::::0;53438:95:::1;;;::::0;-1:-1:-1;;;53438:95:0;;8068:2:1;53438:95:0::1;::::0;::::1;8050:21:1::0;8107:2;8087:18;;;8080:30;8146:34;8126:18;;;8119:62;-1:-1:-1;;;8197:18:1;;;8190:40;8247:19;;53438:95:0::1;7866:406:1::0;53438:95:0::1;-1:-1:-1::0;;;;;53544:28:0;::::1;;::::0;;;:19:::1;:28;::::0;;;;;;;;:39;;-1:-1:-1;;53544:39:0::1;::::0;::::1;;::::0;;::::1;::::0;;;53601:34;;1266:41:1;;;53601:34:0::1;::::0;1239:18:1;53601:34:0::1;;;;;;;53353:290:::0;;:::o;53649:304::-;2686:13;:11;:13::i;:::-;53766:9:::1;53762:115;53781:19:::0;;::::1;53762:115;;;53857:8;53822:19;:32;53842:8;;53851:1;53842:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;53822:32:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;53822:32:0;:43;;-1:-1:-1;;53822:43:0::1;::::0;::::1;;::::0;;;::::1;::::0;;-1:-1:-1;53802:3:0::1;53762:115;;;;53894:51;53926:8;;53936;53894:51;;;;;;;;:::i;:::-;;;;;;;;53649:304:::0;;;:::o;52495:169::-;2686:13;:11;:13::i;:::-;52571:22:::1;:32:::0;;;::::1;;;;-1:-1:-1::0;;52571:32:0;;::::1;;::::0;;52619:37:::1;::::0;::::1;::::0;::::1;::::0;52596:7;1291:14:1;1284:22;1266:41;;1254:2;1239:18;;1126:187;52619:37:0::1;;;;;;;;52495:169:::0;:::o;42529:138::-;2686:13;:11;:13::i;:::-;42627:31:::1;::::0;-1:-1:-1;;;42627:31:0;;42652:4:::1;42627:31;::::0;::::1;2323:51:1::0;42595:64:0::1;::::0;42615:10:::1;::::0;-1:-1:-1;;;;;42627:16:0;::::1;::::0;::::1;::::0;2296:18:1;;42627:31:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;42595:19:0;::::1;::::0;:64;:19:::1;:64::i;18534:142::-:0;-1:-1:-1;;;;;18641:18:0;;;18614:7;18641:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;18534:142::o;3733:220::-;2686:13;:11;:13::i;:::-;-1:-1:-1;;;;;3818:22:0;::::1;3814:93;;3864:31;::::0;-1:-1:-1;;;3864:31:0;;3892:1:::1;3864:31;::::0;::::1;2323:51:1::0;2296:18;;3864:31:0::1;2150:230:1::0;3814:93:0::1;3917:28;3936:8;3917:18;:28::i;52670:331::-:0;2686:13;:11;:13::i;:::-;52761:16:::1;:31:::0;;;52803:16:::1;:31:::0;;;52860:35:::1;52822:12:::0;52780;52860:35:::1;:::i;:::-;52845:12;:50:::0;;;49895:3:::1;-1:-1:-1::0;52936:29:0::1;52928:65;;;::::0;-1:-1:-1;;;52928:65:0;;9599:2:1;52928:65:0::1;::::0;::::1;9581:21:1::0;9638:2;9618:18;;;9611:30;9677:25;9657:18;;;9650:53;9720:18;;52928:65:0::1;9397:347:1::0;52274:83:0;2686:13;:11;:13::i;:::-;52325:17:::1;:24:::0;;-1:-1:-1;;;;52325:24:0::1;-1:-1:-1::0;;;52325:24:0::1;::::0;;52274:83::o;23822:130::-;23907:37;23916:5;23923:7;23932:5;23939:4;23907:8;:37::i;:::-;23822:130;;;:::o;2965:166::-;2873:6;;-1:-1:-1;;;;;2873:6:0;862:10;3025:23;3021:103;;3072:40;;-1:-1:-1;;;3072:40:0;;862:10;3072:40;;;2323:51:1;2296:18;;3072:40:0;2150:230:1;31628:340:0;31738:6;31714:21;:30;31710:111;;;31768:41;;-1:-1:-1;;;31768:41:0;;31803:4;31768:41;;;2323:51:1;2296:18;;31768:41:0;2150:230:1;31710:111:0;31834:12;31852:9;-1:-1:-1;;;;;31852:14:0;31874:6;31852:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31833:52;;;31901:7;31896:65;;31932:17;;-1:-1:-1;;;31932:17:0;;;;;;;;;;;25538:487;25638:24;25665:25;25675:5;25682:7;25665:9;:25::i;:::-;25638:52;;-1:-1:-1;;25705:16:0;:37;25701:317;;25782:5;25763:16;:24;25759:132;;;25815:60;;-1:-1:-1;;;25815:60:0;;-1:-1:-1;;;;;10179:32:1;;25815:60:0;;;10161:51:1;10228:18;;;10221:34;;;10271:18;;;10264:34;;;10134:18;;25815:60:0;9959:345:1;25759:132:0;25934:57;25943:5;25950:7;25978:5;25959:16;:24;25985:5;25934:8;:57::i;:::-;25627:398;25538:487;;;:::o;20397:308::-;-1:-1:-1;;;;;20481:18:0;;20477:88;;20523:30;;-1:-1:-1;;;20523:30:0;;20550:1;20523:30;;;2323:51:1;2296:18;;20523:30:0;2150:230:1;20477:88:0;-1:-1:-1;;;;;20579:16:0;;20575:88;;20619:32;;-1:-1:-1;;;20619:32:0;;20648:1;20619:32;;;2323:51:1;2296:18;;20619:32:0;2150:230:1;20575:88:0;20673:24;20681:4;20687:2;20691:5;20673:7;:24::i;4113:191::-;4206:6;;;-1:-1:-1;;;;;4223:17:0;;;-1:-1:-1;;;;;;4223:17:0;;;;;;;4256:40;;4206:6;;;4223:17;4206:6;;4256:40;;4187:16;;4256:40;4176:128;4113:191;:::o;56037:1475::-;51938:17;:24;;-1:-1:-1;;51938:24:0;51958:4;51938:24;;;56126:22:::1;::::0;:26;56122:374:::1;;56207:22;56257:20;56232:22;;:45;:93;;56303:22;;56232:93;;;56280:20;56232:93;56207:118;;56340:41;56366:14;56340:25;:41::i;:::-;56437:4;18031:7:::0;18058:18;;;;;;;;;;;56483:1:::1;56458:22;:26:::0;56396:47;-1:-1:-1;;56122:374:0::1;56586:32;56621:24;56644:1;56621:20:::0;:24:::1;:::i;:::-;56586:59:::0;-1:-1:-1;56704:14:0::1;56721:45;56586:59:::0;56721:20;:45:::1;:::i;:::-;56704:62:::0;-1:-1:-1;57077:21:0::1;57143:39;56704:62:::0;57176:4:::1;57143:16;:39::i;:::-;57236:29;57268:36;57290:14:::0;57268:21:::1;:36;:::i;:::-;57236:68;;57354:61;57367:24;57393:21;57354:12;:61::i;:::-;57441:63;::::0;;10838:25:1;;;10894:2;10879:18;;10872:34;;;57441:63:0::1;::::0;10811:18:1;57441:63:0::1;;;;;;;-1:-1:-1::0;;51985:17:0;:25;;-1:-1:-1;;51985:25:0;;;-1:-1:-1;;;56037:1475:0:o;37730:162::-;37840:43;;;-1:-1:-1;;;;;11109:32:1;;37840:43:0;;;11091:51:1;11158:18;;;;11151:34;;;37840:43:0;;;;;;;;;;11064:18:1;;;;37840:43:0;;;;;;;;-1:-1:-1;;;;;37840:43:0;-1:-1:-1;;;37840:43:0;;;37813:71;;37833:5;;37813:19;:71::i;24803:443::-;-1:-1:-1;;;;;24916:19:0;;24912:91;;24959:32;;-1:-1:-1;;;24959:32:0;;24988:1;24959:32;;;2323:51:1;2296:18;;24959:32:0;2150:230:1;24912:91:0;-1:-1:-1;;;;;25017:21:0;;25013:92;;25062:31;;-1:-1:-1;;;25062:31:0;;25090:1;25062:31;;;2323:51:1;2296:18;;25062:31:0;2150:230:1;25013:92:0;-1:-1:-1;;;;;25115:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;25161:78;;;;25212:7;-1:-1:-1;;;;;25196:31:0;25205:5;-1:-1:-1;;;;;25196:31:0;;25221:5;25196:31;;;;1464:25:1;;1452:2;1437:18;;1318:177;25196:31:0;;;;;;;;24803:443;;;;:::o;58488:287::-;58580:17;58588:4;58594:2;58580:7;:17::i;:::-;58579:18;:47;;;-1:-1:-1;;;;;;58601:25:0;;;;;;:19;:25;;;;;;;;58579:47;:74;;;-1:-1:-1;;;;;;58630:23:0;;;;;;:19;:23;;;;;;;;58579:74;58575:193;;;58670:30;58684:4;58690:2;58694:5;58670:13;:30::i;58575:193::-;58733:23;58740:4;58746:2;58750:5;58733:6;:23::i;55519:130::-;55624:16;;55594:47;;55611:11;;-1:-1:-1;;;;;55624:16:0;54832:675;54994:16;;;55008:1;54994:16;;;;;;;;54970:21;;54994:16;;;;;;;;;;-1:-1:-1;54994:16:0;54970:40;;55039:4;55021;55026:1;55021:7;;;;;;;;:::i;:::-;;;;;;:23;-1:-1:-1;;;;;55021:23:0;;;-1:-1:-1;;;;;55021:23:0;;;;;55065:5;55055:4;55060:1;55055:7;;;;;;;;:::i;:::-;;;;;;:15;-1:-1:-1;;;;;55055:15:0;;;-1:-1:-1;;;;;55055:15:0;;;;;55140:11;55086:51;55104:4;55119:16;55086:9;:51::i;:::-;:65;55083:164;;;55166:69;55183:4;55198:16;-1:-1:-1;;55166:8:0;:69::i;:::-;55285:214;;-1:-1:-1;;;55285:214:0;;-1:-1:-1;;;;;55285:16:0;:67;;;;:214;;55367:11;;55393:1;;55437:4;;55456:2;;55473:15;;55285:214;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54899:608;54832:675;;:::o;55657:372::-;55768:16;-1:-1:-1;;;;;55768:32:0;;55808:9;55841:4;55861:11;55887:1;55930;55973:7;2873:6;;-1:-1:-1;;;;;2873:6:0;;2800:87;55973:7;55768:253;;;;;;-1:-1:-1;;;;;;55768:253:0;;;-1:-1:-1;;;;;12672:15:1;;;55768:253:0;;;12654:34:1;12704:18;;;12697:34;;;;12747:18;;;12740:34;;;;12790:18;;;12783:34;12854:15;;;12833:19;;;12826:44;55995:15:0;12886:19:1;;;12879:35;12588:19;;55768:253:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;55657:372;;:::o;40541:638::-;40965:23;40991:33;-1:-1:-1;;;;;40991:27:0;;41019:4;40991:27;:33::i;:::-;40965:59;;41039:10;:17;41060:1;41039:22;;:57;;;;;41077:10;41066:30;;;;;;;;;;;;:::i;:::-;41065:31;41039:57;41035:137;;;41120:40;;-1:-1:-1;;;41120:40:0;;-1:-1:-1;;;;;2341:32:1;;41120:40:0;;;2323:51:1;2296:18;;41120:40:0;2150:230:1;57998:166:0;-1:-1:-1;;;;;58088:33:0;;58064:4;58088:33;;;:27;:33;;;;;;;;;:68;;-1:-1:-1;;;;;;;58125:31:0;;;;;:27;:31;;;;;;;;;58081:75;-1:-1:-1;57998:166:0:o;21029:1135::-;-1:-1:-1;;;;;21119:18:0;;21115:552;;21273:5;21257:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;21115:552:0;;-1:-1:-1;21115:552:0;;-1:-1:-1;;;;;21333:15:0;;21311:19;21333:15;;;;;;;;;;;21367:19;;;21363:117;;;21414:50;;-1:-1:-1;;;21414:50:0;;-1:-1:-1;;;;;10179:32:1;;21414:50:0;;;10161:51:1;10228:18;;;10221:34;;;10271:18;;;10264:34;;;10134:18;;21414:50:0;9959:345:1;21363:117:0;-1:-1:-1;;;;;21603:15:0;;:9;:15;;;;;;;;;;21621:19;;;;21603:37;;21115:552;-1:-1:-1;;;;;21683:16:0;;21679:435;;21849:12;:21;;;;;;;21679:435;;;-1:-1:-1;;;;;22065:13:0;;:9;:13;;;;;;;;;;:22;;;;;;21679:435;22146:2;-1:-1:-1;;;;;22131:25:0;22140:4;-1:-1:-1;;;;;22131:25:0;;22150:5;22131:25;;;;1464::1;;1452:2;1437:18;;1318:177;22131:25:0;;;;;;;;21029:1135;;;:::o;58890:1077::-;52099:17;;58975:4;;58981:2;;-1:-1:-1;;;52099:17:0;;;;;:46;;-1:-1:-1;;;;;;52120:25:0;;;;;;:19;:25;;;;;;;;52099:46;:73;;;-1:-1:-1;;;;;;52149:23:0;;;;;;:19;:23;;;;;;;;52099:73;52091:110;;;;-1:-1:-1;;;52091:110:0;;13688:2:1;52091:110:0;;;13670:21:1;13727:2;13707:18;;;13700:30;13766:26;13746:18;;;13739:54;13810:18;;52091:110:0;13486:348:1;52091:110:0;58997:20:::1;59019::::0;59041:16:::1;59061:21;59077:4;59061:15;:21::i;:::-;58996:86:::0;;-1:-1:-1;58996:86:0;-1:-1:-1;58996:86:0;-1:-1:-1;59099:12:0;;59095:435:::1;;59128:22;59153:46;:5:::0;59186:12;59153:32:::1;:46::i;:::-;59128:71:::0;-1:-1:-1;59214:22:0::1;59239:46;:5:::0;59272:12;59239:32:::1;:46::i;:::-;59214:71:::0;-1:-1:-1;59300:21:0::1;59324:31;59214:71:::0;59324:14;:31:::1;:::i;:::-;59300:55:::0;-1:-1:-1;59378:21:0::1;59300:55:::0;59378:5;:21:::1;:::i;:::-;59370:29;;59414:49;59428:4;59442;59449:13;59414;:49::i;:::-;59504:14;59478:22;;:40;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;;59095:435:0::1;59586:4;59537:28;18058:18:::0;;;;;;;;;;;59654:19:::1;::::0;59630:43;::::1;::::0;::::1;::::0;;;59701:54:::1;;-1:-1:-1::0;59738:17:0::1;::::0;::::1;;59737:18;59701:54;:102;;;;-1:-1:-1::0;;;;;;59772:31:0;::::1;;::::0;;;:27:::1;:31;::::0;;;;;::::1;;59701:102;:141;;;;-1:-1:-1::0;59820:22:0::1;::::0;::::1;::::0;::::1;;;59701:141;59684:233;;;59869:36;59884:20;59869:14;:36::i;:::-;59929:30;59943:4;59949:2;59953:5;59929:13;:30::i;:::-;58985:982;;;;;58890:1077:::0;;;;;:::o;32831:153::-;32906:12;32938:38;32960:6;32968:4;32974:1;32938:21;:38::i;57518:474::-;-1:-1:-1;;;;;57657:33:0;;57580:20;57657:33;;;:27;:33;;;;;;57580:20;;;;57657:33;;57653:332;;;57722:16;;57707:31;;57768:16;;57753:31;;57810:12;;57799:23;;57653:332;;;57870:17;;57855:32;;57917:17;;57902:32;;57960:13;;57949:24;;57653:332;57518:474;;;;;:::o;48630:311::-;48727:7;48750:17;;;:33;;-1:-1:-1;48771:12:0;;48750:33;48747:187;;;-1:-1:-1;48807:1:0;48800:8;;48747:187;48841:16;48887:5;48861:22;48871:12;48861:7;:22;:::i;:::-;48860:32;;;;:::i;:::-;48841:51;-1:-1:-1;48907:15:0;;-1:-1:-1;48907:15:0;33319:398;33418:12;33471:5;33447:21;:29;33443:110;;;33500:41;;-1:-1:-1;;;33500:41:0;;33535:4;33500:41;;;2323:51:1;2296:18;;33500:41:0;2150:230:1;33443:110:0;33564:12;33578:23;33605:6;-1:-1:-1;;;;;33605:11:0;33624:5;33631:4;33605:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33563:73;;;;33654:55;33681:6;33689:7;33698:10;33654:26;:55::i;:::-;33647:62;33319:398;-1:-1:-1;;;;;;33319:398:0:o;34795:597::-;34943:12;34973:7;34968:417;;34997:19;35005:10;34997:7;:19::i;:::-;34968:417;;;35225:17;;:22;:49;;;;-1:-1:-1;;;;;;35251:18:0;;;:23;35225:49;35221:121;;;35302:24;;-1:-1:-1;;;35302:24:0;;-1:-1:-1;;;;;2341:32:1;;35302:24:0;;;2323:51:1;2296:18;;35302:24:0;2150:230:1;35221:121:0;-1:-1:-1;35363:10:0;35356:17;;35945:528;36078:17;;:21;36074:392;;36310:10;36304:17;36367:15;36354:10;36350:2;36346:19;36339:44;36074:392;36437:17;;-1:-1:-1;;;36437:17:0;;;;;;;;;;;14:250:1;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:396::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;649:2;628:15;-1:-1:-1;;624:29:1;609:45;;;;656:2;605:54;;269:396;-1:-1:-1;;269:396:1:o;670:131::-;-1:-1:-1;;;;;745:31:1;;735:42;;725:70;;791:1;788;781:12;806:315;874:6;882;935:2;923:9;914:7;910:23;906:32;903:52;;;951:1;948;941:12;903:52;990:9;977:23;1009:31;1034:5;1009:31;:::i;:::-;1059:5;1111:2;1096:18;;;;1083:32;;-1:-1:-1;;;806:315:1:o;1500:456::-;1577:6;1585;1593;1646:2;1634:9;1625:7;1621:23;1617:32;1614:52;;;1662:1;1659;1652:12;1614:52;1701:9;1688:23;1720:31;1745:5;1720:31;:::i;:::-;1770:5;-1:-1:-1;1827:2:1;1812:18;;1799:32;1840:33;1799:32;1840:33;:::i;:::-;1500:456;;1892:7;;-1:-1:-1;;;1946:2:1;1931:18;;;;1918:32;;1500:456::o;2385:247::-;2444:6;2497:2;2485:9;2476:7;2472:23;2468:32;2465:52;;;2513:1;2510;2503:12;2465:52;2552:9;2539:23;2571:31;2596:5;2571:31;:::i;2637:248::-;2705:6;2713;2766:2;2754:9;2745:7;2741:23;2737:32;2734:52;;;2782:1;2779;2772:12;2734:52;-1:-1:-1;;2805:23:1;;;2875:2;2860:18;;;2847:32;;-1:-1:-1;2637:248:1:o;3322:118::-;3408:5;3401:13;3394:21;3387:5;3384:32;3374:60;;3430:1;3427;3420:12;3445:382;3510:6;3518;3571:2;3559:9;3550:7;3546:23;3542:32;3539:52;;;3587:1;3584;3577:12;3539:52;3626:9;3613:23;3645:31;3670:5;3645:31;:::i;:::-;3695:5;-1:-1:-1;3752:2:1;3737:18;;3724:32;3765:30;3724:32;3765:30;:::i;:::-;3814:7;3804:17;;;3445:382;;;;;:::o;3832:180::-;3891:6;3944:2;3932:9;3923:7;3919:23;3915:32;3912:52;;;3960:1;3957;3950:12;3912:52;-1:-1:-1;3983:23:1;;3832:180;-1:-1:-1;3832:180:1:o;4017:750::-;4109:6;4117;4125;4178:2;4166:9;4157:7;4153:23;4149:32;4146:52;;;4194:1;4191;4184:12;4146:52;4234:9;4221:23;4263:18;4304:2;4296:6;4293:14;4290:34;;;4320:1;4317;4310:12;4290:34;4358:6;4347:9;4343:22;4333:32;;4403:7;4396:4;4392:2;4388:13;4384:27;4374:55;;4425:1;4422;4415:12;4374:55;4465:2;4452:16;4491:2;4483:6;4480:14;4477:34;;;4507:1;4504;4497:12;4477:34;4562:7;4555:4;4545:6;4542:1;4538:14;4534:2;4530:23;4526:34;4523:47;4520:67;;;4583:1;4580;4573:12;4520:67;4614:4;4606:13;;;;-1:-1:-1;4638:6:1;-1:-1:-1;;4679:20:1;;4666:34;4709:28;4666:34;4709:28;:::i;:::-;4756:5;4746:15;;;4017:750;;;;;:::o;4772:241::-;4828:6;4881:2;4869:9;4860:7;4856:23;4852:32;4849:52;;;4897:1;4894;4887:12;4849:52;4936:9;4923:23;4955:28;4977:5;4955:28;:::i;5284:388::-;5352:6;5360;5413:2;5401:9;5392:7;5388:23;5384:32;5381:52;;;5429:1;5426;5419:12;5381:52;5468:9;5455:23;5487:31;5512:5;5487:31;:::i;:::-;5537:5;-1:-1:-1;5594:2:1;5579:18;;5566:32;5607:33;5566:32;5607:33;:::i;5677:380::-;5756:1;5752:12;;;;5799;;;5820:61;;5874:4;5866:6;5862:17;5852:27;;5820:61;5927:2;5919:6;5916:14;5896:18;5893:38;5890:161;;5973:10;5968:3;5964:20;5961:1;5954:31;6008:4;6005:1;5998:15;6036:4;6033:1;6026:15;5890:161;;5677:380;;;:::o;6419:127::-;6480:10;6475:3;6471:20;6468:1;6461:31;6511:4;6508:1;6501:15;6535:4;6532:1;6525:15;6551:125;6616:9;;;6637:10;;;6634:36;;;6650:18;;:::i;8277:127::-;8338:10;8333:3;8329:20;8326:1;8319:31;8369:4;8366:1;8359:15;8393:4;8390:1;8383:15;8409:794;8631:2;8643:21;;;8616:18;;8699:22;;;8583:4;8778:6;8752:2;8737:18;;8583:4;8812:304;8826:6;8823:1;8820:13;8812:304;;;8901:6;8888:20;8921:31;8946:5;8921:31;:::i;:::-;-1:-1:-1;;;;;8977:31:1;8965:44;;9032:4;9091:15;;;;9056:12;;;;9005:1;8841:9;8812:304;;;8816:3;9133;9125:11;;;;9188:6;9181:14;9174:22;9167:4;9156:9;9152:20;9145:52;8409:794;;;;;;:::o;9208:184::-;9278:6;9331:2;9319:9;9310:7;9306:23;9302:32;9299:52;;;9347:1;9344;9337:12;9299:52;-1:-1:-1;9370:16:1;;9208:184;-1:-1:-1;9208:184:1:o;10309:217::-;10349:1;10375;10365:132;;10419:10;10414:3;10410:20;10407:1;10400:31;10454:4;10451:1;10444:15;10482:4;10479:1;10472:15;10365:132;-1:-1:-1;10511:9:1;;10309:217::o;10531:128::-;10598:9;;;10619:11;;;10616:37;;;10633:18;;:::i;11328:980::-;11590:4;11638:3;11627:9;11623:19;11669:6;11658:9;11651:25;11695:2;11733:6;11728:2;11717:9;11713:18;11706:34;11776:3;11771:2;11760:9;11756:18;11749:31;11800:6;11835;11829:13;11866:6;11858;11851:22;11904:3;11893:9;11889:19;11882:26;;11943:2;11935:6;11931:15;11917:29;;11964:1;11974:195;11988:6;11985:1;11982:13;11974:195;;;12053:13;;-1:-1:-1;;;;;12049:39:1;12037:52;;12144:15;;;;12109:12;;;;12085:1;12003:9;11974:195;;;-1:-1:-1;;;;;;;12225:32:1;;;;12220:2;12205:18;;12198:60;-1:-1:-1;;;12289:3:1;12274:19;12267:35;12186:3;11328:980;-1:-1:-1;;;11328:980:1:o;12925:306::-;13013:6;13021;13029;13082:2;13070:9;13061:7;13057:23;13053:32;13050:52;;;13098:1;13095;13088:12;13050:52;13127:9;13121:16;13111:26;;13177:2;13166:9;13162:18;13156:25;13146:35;;13221:2;13210:9;13206:18;13200:25;13190:35;;12925:306;;;;;:::o;13236:245::-;13303:6;13356:2;13344:9;13335:7;13331:23;13327:32;13324:52;;;13372:1;13369;13362:12;13324:52;13404:9;13398:16;13423:28;13445:5;13423:28;:::i;13839:168::-;13912:9;;;13943;;13960:15;;;13954:22;;13940:37;13930:71;;13981:18;;:::i;14012:287::-;14141:3;14179:6;14173:13;14195:66;14254:6;14249:3;14242:4;14234:6;14230:17;14195:66;:::i;:::-;14277:16;;;;;14012:287;-1:-1:-1;;14012:287:1:o

Swarm Source

ipfs://2f40d0dd66b485bc8d9d57c507a813042f284ee7aeec1a1a9237ab5e4bafa39d

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