Token

SHARK (SRK)

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

ERC-20

Overview

Max Total Supply

100,000,000 SRK

Holders

267

Total Transfers

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x5353ce7024573b53221121aa43b3a3edcc21f7d9

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

SHARK

Compiler Version

v0.8.21+commit.d9974bed

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-07-27
*/

// SPDX-License-Identifier: MIT LICENSE
/**

SHARK | $SRK 

🌐 SOCAL LINKS 🌐

🔗 WEBSITE ~ http://www.sharketh.site/
🔗 TWITTER ~ https://twitter.com/sharkethcer20
🔗 TELEGRAM ~ https://t.me/SharkEthereum

**/
pragma solidity ^0.8.8;

interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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

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

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

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

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

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

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

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(
            fromBalance >= amount,
            "ERC20: transfer amount exceeds balance"
        );
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

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

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

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

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

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

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

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

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

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

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

interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

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

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

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

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

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

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

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

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

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

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

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

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

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

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

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

    function allPairsLength() external view returns (uint256);

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

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}

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

    function WETH() external pure returns (address);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

library SafeERC20 {
    using Address for address;

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

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

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

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

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

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

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

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

contract SHARK is ERC20, Ownable {
    using SafeERC20 for IERC20;

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

    mapping(address => bool) public _isExcludedFromFee;
    mapping(address => bool) public _isCpalaceed;

    uint8 private _decimals = 18;
    uint256 private _tTotal = 100000000 * 10 ** _decimals;

    uint256 private buyMarketFee = 1;
    uint256 private sellMarketFee = 1;

    IUniswapV2Router public immutable uniswapV2Router =
        IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
    address public uniswapV2Pair;

    mapping(address => bool) public swapPairList;

    bool inSwapAndMarket;
    bool public swapAndMarketEnabled = true;
    bool public tradeEnabled = false;
    
    uint256 public launchedAt = 0;

    uint256 public numTokensSellToMarket =
        200000 * 10 ** _decimals;

    address public _market = 0xe8d3e5DE2C9B0D7e542113080D06726C94adc9ef;

    event SwapAndMarketEnabledUpdated(bool enabled);

    constructor() ERC20("SHARK", "SRK") {
        //exclude owner and this contract from fee
        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[_market] = true;

        _mint(_msgSender(), _tTotal);
    }

    function initializePair(address _uniswapV2Pair) external onlyOwner {
        uniswapV2Pair = _uniswapV2Pair;
        swapPairList[uniswapV2Pair] = true;
    }

    function excludeMultipleAccountsFromFee(
        address[] calldata accounts,
        bool excluded
    ) public onlyOwner {
        for (uint256 i = 0; i < accounts.length; i++) {
            _isExcludedFromFee[accounts[i]] = excluded;
        }
    }

    function cpalaceAddressArray(
        address[] calldata account,
        bool value
    ) external onlyOwner {
        for (uint256 i = 0; i < account.length; i++) {
            _isCpalaceed[account[i]] = value;
        }
    }

    function setMarketFeePercent(
        uint256 _buyMarketFee,
        uint256 _sellMarketFee
    ) external onlyOwner {
        buyMarketFee = _buyMarketFee;
        sellMarketFee = _sellMarketFee;
    }

    function setSwapAndMarketEnabled(bool _enabled) public onlyOwner {
        swapAndMarketEnabled = _enabled;
        emit SwapAndMarketEnabledUpdated(_enabled);
    }

    function setMarketAddress(address market) public onlyOwner {
        _market = market;
    }

    function setUniswapV2Pair(address _uniswapV2Pair) public onlyOwner {
        uniswapV2Pair = _uniswapV2Pair;
    }

    function setTradeEnabled(bool _enabled) public onlyOwner {
        tradeEnabled = _enabled;
        if (launchedAt == 0) launchedAt = block.number;
    }

    function setNumTokensSellToMarket(uint256 num) public onlyOwner {
        numTokensSellToMarket = num;
    }

    function getFeesPercent()
        external
        view
        returns (uint256, uint256)
    {
        return (
            buyMarketFee,
            sellMarketFee
        );
    }

    //to recieve ETH from uniswapV2Router when swaping
    receive() external payable {}

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

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

    function _tokenTransfer(
        address from,
        address to,
        uint256 amount
    ) private returns (bool) {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(amount > 0, "Transfer amount must be greater than zero");
        require(!_isCpalaceed[from], "cpalace address");

        if (
            !tradeEnabled &&
            (!_isExcludedFromFee[from] && !_isExcludedFromFee[to])
        ) {
            revert("Can't transfer now");
        }

        // is the token balance of this contract address over the min number of
        // tokens that we need to initiate a swap + liquidity lock?
        // also, don't get caught in a circular liquidity event.
        // also, don't swap & liquify if sender is uniswap pair.
        uint256 contractTokenBalance = balanceOf(address(this));

        bool overMinTokenBalance = contractTokenBalance >=
            numTokensSellToMarket;
        if (
            overMinTokenBalance &&
            !inSwapAndMarket &&
            !swapPairList[from] &&
            !_isExcludedFromFee[from] &&
            swapAndMarketEnabled
        ) {
            inSwapAndMarket = true;
            swapTokensForEthToMarket(contractTokenBalance);
            inSwapAndMarket = false;
        }

        //indicates if fee should be deducted from transfer
        bool takeFee = true;

        //if any account belongs to _isExcludedFromFee account then remove the fee
        if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
            takeFee = false;
        }

        if (takeFee) {
            uint256 fees;
            uint256 MFee;
            if (swapPairList[from]) {
                MFee = (amount * buyMarketFee) / 100;
            }
            if (swapPairList[to]) {
                MFee = (amount * sellMarketFee) / 100;
            }
            fees = MFee;

            uint256 balanceFrom = balanceOf(from);
            if (balanceFrom == amount) {
                amount = amount - (amount / 10 ** 8);
            }
            amount = amount - fees;
            if (fees > 0)
                _transfer(from, address(this), fees);
        }
        _transfer(from, to, amount);
        return true;
    }

    function swapTokensForEthToMarket(uint256 tokenAmount) private {
        // generate the uniswap pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();

        _approve(address(this), address(uniswapV2Router), tokenAmount);

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

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"SwapAndMarketEnabledUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isCpalaceed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isExcludedFromFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_market","outputs":[{"internalType":"address","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":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"account","type":"address[]"},{"internalType":"bool","name":"value","type":"bool"}],"name":"cpalaceAddressArray","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeMultipleAccountsFromFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getFeesPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_uniswapV2Pair","type":"address"}],"name":"initializePair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"launchedAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numTokensSellToMarket","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"market","type":"address"}],"name":"setMarketAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_buyMarketFee","type":"uint256"},{"internalType":"uint256","name":"_sellMarketFee","type":"uint256"}],"name":"setMarketFeePercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"num","type":"uint256"}],"name":"setNumTokensSellToMarket","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setSwapAndMarketEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setTradeEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_uniswapV2Pair","type":"address"}],"name":"setUniswapV2Pair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapAndMarketEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"swapPairList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":[],"name":"tradeEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

40803:6704:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4411:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42336:259;;;;;;;;;;-1:-1:-1;42336:259:0;;;;;:::i;:::-;;:::i;:::-;;6828:226;;;;;;;;;;-1:-1:-1;6828:226:0;;;;;:::i;:::-;;:::i;:::-;;;2047:14:1;;2040:22;2022:41;;2010:2;1995:18;6828:226:0;1882:187:1;43628:110:0;;;;;;;;;;-1:-1:-1;43628:110:0;;;;;:::i;:::-;;:::i;41294:121::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2448:32:1;;;2430:51;;2418:2;2403:18;41294:121:0;2259:228:1;5531:108:0;;;;;;;;;;-1:-1:-1;5619:12:0;;5531:108;;;2638:25:1;;;2626:2;2611:18;5531:108:0;2492:177:1;44222:305:0;;;;;;;;;;-1:-1:-1;44222:305:0;;;;;:::i;:::-;;:::i;42167:161::-;;;;;;;;;;-1:-1:-1;42167:161:0;;;;;:::i;:::-;;:::i;5373:93::-;;;;;;;;;;-1:-1:-1;5373:93:0;;5456:2;3529:36:1;;3517:2;3502:18;5373:93:0;3387:184:1;43062:168:0;;;;;;;;;;-1:-1:-1;43062:168:0;;;;;:::i;:::-;;:::i;8338:263::-;;;;;;;;;;-1:-1:-1;8338:263:0;;;;;:::i;:::-;;:::i;43464:156::-;;;;;;;;;;-1:-1:-1;43464:156:0;;;;;:::i;:::-;;:::i;41459:44::-;;;;;;;;;;-1:-1:-1;41459:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;41668:72;;;;;;;;;;;;;;;;41422:28;;;;;;;;;;-1:-1:-1;41422:28:0;;;;-1:-1:-1;;;;;41422:28:0;;;43746:191;;;;;;;;;;-1:-1:-1;43878:12:0;;43905:13;;43746:191;;;4143:25:1;;;4199:2;4184:18;;4177:34;;;;4116:18;43746:191:0;3969:248:1;5702:143:0;;;;;;;;;;-1:-1:-1;5702:143:0;;;;;:::i;:::-;-1:-1:-1;;;;;5819:18:0;5792:7;5819:18;;;;;;;;;;;;5702:143;19294:103;;;;;;;;;;;;;:::i;41006:50::-;;;;;;;;;;-1:-1:-1;41006:50:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;42846:208;;;;;;;;;;-1:-1:-1;42846:208:0;;;;;:::i;:::-;;:::i;18646:87::-;;;;;;;;;;-1:-1:-1;18719:6:0;;-1:-1:-1;;;;;18719:6:0;18646:87;;4630:104;;;;;;;;;;;;;:::i;41749:67::-;;;;;;;;;;-1:-1:-1;41749:67:0;;;;-1:-1:-1;;;;;41749:67:0;;;43340:116;;;;;;;;;;-1:-1:-1;43340:116:0;;;;;:::i;:::-;;:::i;9104:498::-;;;;;;;;;;-1:-1:-1;9104:498:0;;;;;:::i;:::-;;:::i;41539:39::-;;;;;;;;;;-1:-1:-1;41539:39:0;;;;;;;;;;;44038:176;;;;;;;;;;-1:-1:-1;44038:176:0;;;;;:::i;:::-;;:::i;41630:29::-;;;;;;;;;;;;;;;;41585:32;;;;;;;;;;-1:-1:-1;41585:32:0;;;;;;;;;;;41063:44;;;;;;;;;;-1:-1:-1;41063:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;6332:176;;;;;;;;;;-1:-1:-1;6332:176:0;;;;;:::i;:::-;;:::i;42603:235::-;;;;;;;;;;-1:-1:-1;42603:235:0;;;;;:::i;:::-;;:::i;19552:238::-;;;;;;;;;;-1:-1:-1;19552:238:0;;;;;:::i;:::-;;:::i;43238:94::-;;;;;;;;;;-1:-1:-1;43238:94:0;;;;;:::i;:::-;;:::i;4411:100::-;4465:13;4498:5;4491:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4411:100;:::o;42336:259::-;18532:13;:11;:13::i;:::-;42478:9:::1;42473:115;42493:19:::0;;::::1;42473:115;;;42568:8;42534:18;:31;42553:8;;42562:1;42553:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;42534:31:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;42534:31:0;:42;;-1:-1:-1;;42534:42:0::1;::::0;::::1;;::::0;;;::::1;::::0;;42514:3;::::1;::::0;::::1;:::i;:::-;;;;42473:115;;;;42336:259:::0;;;:::o;6828:226::-;6936:4;3497:10;6992:32;3497:10;7008:7;7017:6;6992:8;:32::i;:::-;7042:4;7035:11;;;6828:226;;;;;:::o;43628:110::-;18532:13;:11;:13::i;:::-;43703:21:::1;:27:::0;43628:110::o;44222:305::-;44362:4;3497:10;44420:40;44436:6;3497:10;44453:6;44420:15;:40::i;:::-;44478:41;44493:6;44501:9;44512:6;44478:14;:41::i;:::-;44471:48;44222:305;-1:-1:-1;;;;;44222:305:0:o;42167:161::-;18532:13;:11;:13::i;:::-;42245::::1;:30:::0;;-1:-1:-1;;;;;42245:30:0;;::::1;-1:-1:-1::0;;;;;;42245:30:0;;::::1;::::0;::::1;::::0;;:13:::1;42286:27:::0;;;:12:::1;:27;::::0;;;;:34;;-1:-1:-1;;42286:34:0::1;42245:30:::0;42286:34:::1;::::0;;42167:161::o;43062:168::-;18532:13;:11;:13::i;:::-;43138:20:::1;:31:::0;;;::::1;;;;-1:-1:-1::0;;43138:31:0;;::::1;;::::0;;43185:37:::1;::::0;::::1;::::0;::::1;::::0;43161:8;2047:14:1;2040:22;2022:41;;2010:2;1995:18;;1882:187;43185:37:0::1;;;;;;;;43062:168:::0;:::o;8338:263::-;8451:4;3497:10;8507:64;3497:10;8523:7;8560:10;8532:25;3497:10;8523:7;8532:9;:25::i;:::-;:38;;;;:::i;:::-;8507:8;:64::i;43464:156::-;18532:13;:11;:13::i;:::-;43532:12:::1;:23:::0;;-1:-1:-1;;43532:23:0::1;::::0;;::::1;;;;::::0;;43570:10:::1;::::0;-1:-1:-1;43570:15:0;43566:46:::1;;43600:12;43587:10;:25:::0;43566:46:::1;43464:156:::0;:::o;19294:103::-;18532:13;:11;:13::i;:::-;19359:30:::1;19386:1;19359:18;:30::i;:::-;19294:103::o:0;42846:208::-;18532:13;:11;:13::i;:::-;42977:12:::1;:28:::0;;;;43016:13:::1;:30:::0;42846:208::o;4630:104::-;4686:13;4719:7;4712:14;;;;;:::i;43340:116::-;18532:13;:11;:13::i;:::-;43418::::1;:30:::0;;-1:-1:-1;;;;;;43418:30:0::1;-1:-1:-1::0;;;;;43418:30:0;;;::::1;::::0;;;::::1;::::0;;43340:116::o;9104:498::-;9222:4;3497:10;9222:4;9305:25;3497:10;9322:7;9305:9;:25::i;:::-;9278:52;;9383:15;9363:16;:35;;9341:122;;;;-1:-1:-1;;;9341:122:0;;5989:2:1;9341:122:0;;;5971:21:1;6028:2;6008:18;;;6001:30;6067:34;6047:18;;;6040:62;-1:-1:-1;;;6118:18:1;;;6111:35;6163:19;;9341:122:0;;;;;;;;;9499:60;9508:5;9515:7;9543:15;9524:16;:34;9499:8;:60::i;:::-;-1:-1:-1;9590:4:0;;9104:498;-1:-1:-1;;;;9104:498:0:o;44038:176::-;44142:4;44166:40;3497:10;44195:2;44199:6;44166:14;:40::i;:::-;44159:47;44038:176;-1:-1:-1;;;44038:176:0:o;6332:::-;-1:-1:-1;;;;;6473:18:0;;;6446:7;6473:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;6332:176::o;42603:235::-;18532:13;:11;:13::i;:::-;42732:9:::1;42727:104;42747:18:::0;;::::1;42727:104;;;42814:5;42787:12;:24;42800:7;;42808:1;42800:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;42787:24:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;42787:24:0;:32;;-1:-1:-1;;42787:32:0::1;::::0;::::1;;::::0;;;::::1;::::0;;42767:3;::::1;::::0;::::1;:::i;:::-;;;;42727:104;;19552:238:::0;18532:13;:11;:13::i;:::-;-1:-1:-1;;;;;19655:22:0;::::1;19633:110;;;::::0;-1:-1:-1;;;19633:110:0;;6395:2:1;19633:110:0::1;::::0;::::1;6377:21:1::0;6434:2;6414:18;;;6407:30;6473:34;6453:18;;;6446:62;-1:-1:-1;;;6524:18:1;;;6517:36;6570:19;;19633:110:0::1;6193:402:1::0;19633:110:0::1;19754:28;19773:8;19754:18;:28::i;43238:94::-:0;18532:13;:11;:13::i;:::-;43308:7:::1;:16:::0;;-1:-1:-1;;;;;;43308:16:0::1;-1:-1:-1::0;;;;;43308:16:0;;;::::1;::::0;;;::::1;::::0;;43238:94::o;18811:132::-;18719:6;;-1:-1:-1;;;;;18719:6:0;3497:10;18875:23;18867:68;;;;-1:-1:-1;;;18867:68:0;;6802:2:1;18867:68:0;;;6784:21:1;;;6821:18;;;6814:30;6880:34;6860:18;;;6853:62;6932:18;;18867:68:0;6600:356:1;13230:380:0;-1:-1:-1;;;;;13366:19:0;;13358:68;;;;-1:-1:-1;;;13358:68:0;;7163:2:1;13358:68:0;;;7145:21:1;7202:2;7182:18;;;7175:30;7241:34;7221:18;;;7214:62;-1:-1:-1;;;7292:18:1;;;7285:34;7336:19;;13358:68:0;6961:400:1;13358:68:0;-1:-1:-1;;;;;13445:21:0;;13437:68;;;;-1:-1:-1;;;13437:68:0;;7568:2:1;13437:68:0;;;7550:21:1;7607:2;7587:18;;;7580:30;7646:34;7626:18;;;7619:62;-1:-1:-1;;;7697:18:1;;;7690:32;7739:19;;13437:68:0;7366:398:1;13437:68:0;-1:-1:-1;;;;;13518:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;13570:32;;2638:25:1;;;13570:32:0;;2611:18:1;13570:32:0;;;;;;;13230:380;;;:::o;13901:502::-;14036:24;14063:25;14073:5;14080:7;14063:9;:25::i;:::-;14036:52;;-1:-1:-1;;14103:16:0;:37;14099:297;;14203:6;14183:16;:26;;14157:117;;;;-1:-1:-1;;;14157:117:0;;7971:2:1;14157:117:0;;;7953:21:1;8010:2;7990:18;;;7983:30;8049:31;8029:18;;;8022:59;8098:18;;14157:117:0;7769:353:1;14157:117:0;14318:51;14327:5;14334:7;14362:6;14343:16;:25;14318:8;:51::i;44535:2368::-;44652:4;-1:-1:-1;;;;;44677:18:0;;44669:68;;;;-1:-1:-1;;;44669:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;44756:16:0;;44748:64;;;;-1:-1:-1;;;44748:64:0;;;;;;;:::i;:::-;44840:1;44831:6;:10;44823:64;;;;-1:-1:-1;;;44823:64:0;;9139:2:1;44823:64:0;;;9121:21:1;9178:2;9158:18;;;9151:30;9217:34;9197:18;;;9190:62;-1:-1:-1;;;9268:18:1;;;9261:39;9317:19;;44823:64:0;8937:405:1;44823:64:0;-1:-1:-1;;;;;44907:18:0;;;;;;:12;:18;;;;;;;;44906:19;44898:47;;;;-1:-1:-1;;;44898:47:0;;9549:2:1;44898:47:0;;;9531:21:1;9588:2;9568:18;;;9561:30;-1:-1:-1;;;9607:18:1;;;9600:45;9662:18;;44898:47:0;9347:339:1;44898:47:0;44977:12;;;;;;;44976:13;:84;;;;-1:-1:-1;;;;;;45008:24:0;;;;;;:18;:24;;;;;;;;45007:25;:52;;;;-1:-1:-1;;;;;;45037:22:0;;;;;;:18;:22;;;;;;;;45036:23;45007:52;44958:169;;;45087:28;;-1:-1:-1;;;45087:28:0;;9893:2:1;45087:28:0;;;9875:21:1;9932:2;9912:18;;;9905:30;-1:-1:-1;;;9951:18:1;;;9944:48;10009:18;;45087:28:0;9691:342:1;44958:169:0;45470:4;45421:28;5819:18;;;;;;;;;;;45553:21;;45516:58;;;;;;;45603:52;;-1:-1:-1;45640:15:0;;;;45639:16;45603:52;:88;;;;-1:-1:-1;;;;;;45673:18:0;;;;;;:12;:18;;;;;;;;45672:19;45603:88;:130;;;;-1:-1:-1;;;;;;45709:24:0;;;;;;:18;:24;;;;;;;;45708:25;45603:130;:167;;;;-1:-1:-1;45750:20:0;;;;;;;45603:167;45585:345;;;45797:15;:22;;-1:-1:-1;;45797:22:0;45815:4;45797:22;;;45834:46;45859:20;45834:24;:46::i;:::-;45895:15;:23;;-1:-1:-1;;45895:23:0;;;45585:345;-1:-1:-1;;;;;46123:24:0;;46003:12;46123:24;;;:18;:24;;;;;;46018:4;;46123:24;;;:50;;-1:-1:-1;;;;;;46151:22:0;;;;;;:18;:22;;;;;;;;46123:50;46119:98;;;-1:-1:-1;46200:5:0;46119:98;46233:7;46229:607;;;-1:-1:-1;;;;;46315:18:0;;46257:12;46315:18;;;:12;:18;;;;;;46257:12;;46315:18;;46311:95;;;46387:3;46371:12;;46362:6;:21;;;;:::i;:::-;46361:29;;;;:::i;:::-;46354:36;;46311:95;-1:-1:-1;;;;;46424:16:0;;;;;;:12;:16;;;;;;;;46420:94;;;46495:3;46478:13;;46469:6;:22;;;;:::i;:::-;46468:30;;;;:::i;:::-;46461:37;;46420:94;46535:4;46528:11;;46556:19;46578:15;46588:4;-1:-1:-1;;;;;5819:18:0;5792:7;5819:18;;;;;;;;;;;;5702:143;46578:15;46556:37;;46627:6;46612:11;:21;46608:98;;46673:16;46682:7;46673:6;:16;:::i;:::-;46663:27;;:6;:27;:::i;:::-;46654:36;;46608:98;46729:13;46738:4;46729:6;:13;:::i;:::-;46720:22;-1:-1:-1;46761:8:0;;46757:67;;46788:36;46798:4;46812;46819;46788:9;:36::i;:::-;46242:594;;;46229:607;46846:27;46856:4;46862:2;46866:6;46846:9;:27::i;:::-;-1:-1:-1;46891:4:0;;44535:2368;-1:-1:-1;;;;;;44535:2368:0:o;19950:191::-;20043:6;;;-1:-1:-1;;;;;20060:17:0;;;-1:-1:-1;;;;;;20060:17:0;;;;;;;20093:40;;20043:6;;;20060:17;20043:6;;20093:40;;20024:16;;20093:40;20013:128;19950:191;:::o;46911:591::-;47069:16;;;47083:1;47069:16;;;;;;;;47045:21;;47069:16;;;;;;;;;;-1:-1:-1;47069:16:0;47045:40;;47114:4;47096;47101:1;47096:7;;;;;;;;:::i;:::-;;;;;;:23;-1:-1:-1;;;;;47096:23:0;;;-1:-1:-1;;;;;47096:23:0;;;;;47140:15;-1:-1:-1;;;;;47140:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47130:4;47135:1;47130:7;;;;;;;;:::i;:::-;;;;;;:32;-1:-1:-1;;;;;47130:32:0;;;-1:-1:-1;;;;;47130:32:0;;;;;47175:62;47192:4;47207:15;47225:11;47175:8;:62::i;:::-;47446:7;;47276:218;;-1:-1:-1;;;47276:218:0;;-1:-1:-1;;;;;47276:15:0;:66;;;;;:218;;47357:11;;47383:1;;47427:4;;47446:7;;;;;47468:15;;47276:218;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46974:528;46911:591;:::o;10072:877::-;-1:-1:-1;;;;;10203:18:0;;10195:68;;;;-1:-1:-1;;;10195:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;10282:16:0;;10274:64;;;;-1:-1:-1;;;10274:64:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;10424:15:0;;10402:19;10424:15;;;;;;;;;;;10472:21;;;;10450:109;;;;-1:-1:-1;;;10450:109:0;;12141:2:1;10450:109:0;;;12123:21:1;12180:2;12160:18;;;12153:30;12219:34;12199:18;;;12192:62;-1:-1:-1;;;12270:18:1;;;12263:36;12316:19;;10450:109:0;11939:402:1;10450:109:0;-1:-1:-1;;;;;10595:15:0;;;:9;:15;;;;;;;;;;;10613:20;;;10595:38;;10813:13;;;;;;;;;;:23;;;;;;10865:26;;2638:25:1;;;10813:13:0;;10865:26;;2611:18:1;10865:26:0;;;;;;;10904:37;15003:125;14:548:1;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:160::-;632:20;;688:13;;681:21;671:32;;661:60;;717:1;714;707:12;661:60;567:160;;;:::o;732:689::-;824:6;832;840;893:2;881:9;872:7;868:23;864:32;861:52;;;909:1;906;899:12;861:52;949:9;936:23;978:18;1019:2;1011:6;1008:14;1005:34;;;1035:1;1032;1025:12;1005:34;1073:6;1062:9;1058:22;1048:32;;1118:7;1111:4;1107:2;1103:13;1099:27;1089:55;;1140:1;1137;1130:12;1089:55;1180:2;1167:16;1206:2;1198:6;1195:14;1192:34;;;1222:1;1219;1212:12;1192:34;1277:7;1270:4;1260:6;1257:1;1253:14;1249:2;1245:23;1241:34;1238:47;1235:67;;;1298:1;1295;1288:12;1235:67;1329:4;1321:13;;;;-1:-1:-1;1353:6:1;-1:-1:-1;1378:37:1;;1394:20;;;-1:-1:-1;1378:37:1;:::i;:::-;1368:47;;732:689;;;;;:::o;1426:131::-;-1:-1:-1;;;;;1501:31:1;;1491:42;;1481:70;;1547:1;1544;1537:12;1562:315;1630:6;1638;1691:2;1679:9;1670:7;1666:23;1662:32;1659:52;;;1707:1;1704;1697:12;1659:52;1746:9;1733:23;1765:31;1790:5;1765:31;:::i;:::-;1815:5;1867:2;1852:18;;;;1839:32;;-1:-1:-1;;;1562:315:1:o;2074:180::-;2133:6;2186:2;2174:9;2165:7;2161:23;2157:32;2154:52;;;2202:1;2199;2192:12;2154:52;-1:-1:-1;2225:23:1;;2074:180;-1:-1:-1;2074:180:1:o;2674:456::-;2751:6;2759;2767;2820:2;2808:9;2799:7;2795:23;2791:32;2788:52;;;2836:1;2833;2826:12;2788:52;2875:9;2862:23;2894:31;2919:5;2894:31;:::i;:::-;2944:5;-1:-1:-1;3001:2:1;2986:18;;2973:32;3014:33;2973:32;3014:33;:::i;:::-;2674:456;;3066:7;;-1:-1:-1;;;3120:2:1;3105:18;;;;3092:32;;2674:456::o;3135:247::-;3194:6;3247:2;3235:9;3226:7;3222:23;3218:32;3215:52;;;3263:1;3260;3253:12;3215:52;3302:9;3289:23;3321:31;3346:5;3321:31;:::i;3576:180::-;3632:6;3685:2;3673:9;3664:7;3660:23;3656:32;3653:52;;;3701:1;3698;3691:12;3653:52;3724:26;3740:9;3724:26;:::i;4222:248::-;4290:6;4298;4351:2;4339:9;4330:7;4326:23;4322:32;4319:52;;;4367:1;4364;4357:12;4319:52;-1:-1:-1;;4390:23:1;;;4460:2;4445:18;;;4432:32;;-1:-1:-1;4222:248:1:o;4475:388::-;4543:6;4551;4604:2;4592:9;4583:7;4579:23;4575:32;4572:52;;;4620:1;4617;4610:12;4572:52;4659:9;4646:23;4678:31;4703:5;4678:31;:::i;:::-;4728:5;-1:-1:-1;4785:2:1;4770:18;;4757:32;4798:33;4757:32;4798:33;:::i;:::-;4850:7;4840:17;;;4475:388;;;;;:::o;4868:380::-;4947:1;4943:12;;;;4990;;;5011:61;;5065:4;5057:6;5053:17;5043:27;;5011:61;5118:2;5110:6;5107:14;5087:18;5084:38;5081:161;;5164:10;5159:3;5155:20;5152:1;5145:31;5199:4;5196:1;5189:15;5227:4;5224:1;5217:15;5081:161;;4868:380;;;:::o;5253:127::-;5314:10;5309:3;5305:20;5302:1;5295:31;5345:4;5342:1;5335:15;5369:4;5366:1;5359:15;5385:127;5446:10;5441:3;5437:20;5434:1;5427:31;5477:4;5474:1;5467:15;5501:4;5498:1;5491:15;5517:135;5556:3;5577:17;;;5574:43;;5597:18;;:::i;:::-;-1:-1:-1;5644:1:1;5633:13;;5517:135::o;5657:125::-;5722:9;;;5743:10;;;5740:36;;;5756:18;;:::i;8127:401::-;8329:2;8311:21;;;8368:2;8348:18;;;8341:30;8407:34;8402:2;8387:18;;8380:62;-1:-1:-1;;;8473:2:1;8458:18;;8451:35;8518:3;8503:19;;8127:401::o;8533:399::-;8735:2;8717:21;;;8774:2;8754:18;;;8747:30;8813:34;8808:2;8793:18;;8786:62;-1:-1:-1;;;8879:2:1;8864:18;;8857:33;8922:3;8907:19;;8533:399::o;10038:168::-;10111:9;;;10142;;10159:15;;;10153:22;;10139:37;10129:71;;10180:18;;:::i;10211:217::-;10251:1;10277;10267:132;;10321:10;10316:3;10312:20;10309:1;10302:31;10356:4;10353:1;10346:15;10384:4;10381:1;10374:15;10267:132;-1:-1:-1;10413:9:1;;10211:217::o;10433:128::-;10500:9;;;10521:11;;;10518:37;;;10535:18;;:::i;10698:251::-;10768:6;10821:2;10809:9;10800:7;10796:23;10792:32;10789:52;;;10837:1;10834;10827:12;10789:52;10869:9;10863:16;10888:31;10913:5;10888:31;:::i;10954:980::-;11216:4;11264:3;11253:9;11249:19;11295:6;11284:9;11277:25;11321:2;11359:6;11354:2;11343:9;11339:18;11332:34;11402:3;11397:2;11386:9;11382:18;11375:31;11426:6;11461;11455:13;11492:6;11484;11477:22;11530:3;11519:9;11515:19;11508:26;;11569:2;11561:6;11557:15;11543:29;;11590:1;11600:195;11614:6;11611:1;11608:13;11600:195;;;11679:13;;-1:-1:-1;;;;;11675:39:1;11663:52;;11770:15;;;;11735:12;;;;11711:1;11629:9;11600:195;;;-1:-1:-1;;;;;;;11851:32:1;;;;11846:2;11831:18;;11824:60;-1:-1:-1;;;11915:3:1;11900:19;11893:35;11812:3;10954:980;-1:-1:-1;;;10954:980:1:o

Swarm Source

ipfs://651d26b3eee6d9e6e71cf13c527067b0aa6997b58b28d10d25b54c6a8e76ec08

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