Token

AISHIB (AISHIB)

ERC-20

Deflationary Token

Overview

Max Total Supply

210,000,000,000,000,000 AISHIB

Holders

67,931 ( -0.007%)

Total Transfers

Market

Price

$0.00 @ 0.000000 ETH (-7.49%)

Onchain Market Cap

$0.00

Circulating Supply Market Cap

$0.00

Other Info

Token Contract (WITH 6 Decimals)

0xF1A82bfA7fCEb8B8741e7E04a6B8EfD348cA6393

OVERVIEW

ArbSHIB is a veritable catalyst within the Arbitrum ecosystem. The team behind it has no affiliation with VC institutions or team shares. The creators of the ArbSHIB protocol are a group of passionate AI organisms dedicated to Arbitrum.

Market

Volume (24H)	:	$24.83
Market Capitalization	:	$0.00
Circulating Supply	:	0.00 AISHIB
Market Data Source: Coinmarketcap

Contract Source Code Verified (Exact Match)

Contract Name:

AIShib

Compiler Version

v0.8.19+commit.7dd6d404

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Arbiscan.io on 2023-04-20
*/

/**
 *Submitted for verification at Arbiscan on 2023-04-11
*/

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

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

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

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;



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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }
}

// File: contracts/interfaces/ICamelotFactory.sol


pragma solidity >=0.5.0;

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

    function owner() external view returns (address);

    function feePercentOwner() external view returns (address);

    function setStableOwner() external view returns (address);

    function feeTo() external view returns (address);

    function ownerFeeShare() external view returns (uint256);

    function referrersFeeShare(address) external view returns (uint256);

    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 feeInfo()
        external
        view
        returns (uint _ownerFeeShare, address _feeTo);
}

// File: contracts/interfaces/IUniswapV2Router01.sol


pragma solidity >=0.6.2;

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

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        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 quote(
        uint amountA,
        uint reserveA,
        uint reserveB
    ) external pure returns (uint amountB);

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

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

// File: contracts/interfaces/ICamelotRouter.sol


pragma solidity >=0.6.2;

interface ICamelotRouter 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,
        address referrer,
        uint deadline
    ) external;

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

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

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

// File: contracts/interfaces/IJackpot.sol


pragma solidity >=0.5.0;

interface IJackpot {
    function tradeEvent(address sender, uint256 amount) external;
}

// File: contracts/interfaces/IWETH.sol


pragma solidity >=0.5.0;

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

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

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

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

    function deposit() external payable;

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

    function withdraw(uint256) external;
}

// File: contracts/interfaces/IShibaBonusPool.sol


pragma solidity >=0.5.0;

interface IShibaBonusPool {
    function deposit(uint256 _pid, uint256 _amount) external;
    function withdraw(uint256 _pid, uint256 _amount) external;
    function emergencyWithdraw(uint256 _pid) external;
    function injectRewards(uint256 amount) external;
    function injectRewardsWithTime(uint256 amount, uint256 rewardsSeconds) external;
}

// File: contracts/token/AIShib.sol


pragma solidity =0.8.19;

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

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

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

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

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

    uint256 private burnFee;
    uint256 public gov1Fee;
    uint256 public gov2Fee;
    uint256 private liquidityFee;
    uint256 private jackpotFee;
    uint256 private bonusFee;
    uint256 private devFee;
    uint256 private totalFee;
    uint256 public feeDenominator = 10000;

    // Buy Fees
    uint256 public burnFeeBuy = 100;
    uint256 public gov1FeeBuy = 100;
    uint256 public gov2FeeBuy = 200;
    uint256 public liquidityFeeBuy = 200;
    uint256 public jackpotFeeBuy = 300;
    uint256 public bonusFeeBuy = 300;
    uint256 public devFeeBuy = 300;
    uint256 public totalFeeBuy = 1500;
    // Sell Fees
    uint256 public burnFeeSell = 100;
    uint256 public gov1FeeSell = 100;
    uint256 public gov2FeeSell = 200;
    uint256 public liquidityFeeSell = 200;
    uint256 public jackpotFeeSell = 300;
    uint256 public bonusFeeSell = 300;
    uint256 public devFeeSell = 300;
    uint256 public totalFeeSell = 1500;

    // Fees receivers
    address private gov1Wallet;
    address private gov2Wallet;
    address private bonusWallet;
    IJackpot public jackpotWallet;
    address private devWallet;

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

    ICamelotFactory private immutable factory;
    ICamelotRouter private immutable swapRouter;
    IWETH private immutable WETH;
    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
    address private constant ZERO = 0x0000000000000000000000000000000000000000;

    EnumerableSet.AddressSet private _pairs;

    constructor(
        IERC20 _backToken,
        address _factory,
        address _swapRouter,
        address _weth
    ) ERC20("AISHIB", "AISHIB") {
        uint256 _totalSupply = 210_000_000_000_000_000 * 1e6;
        backToken = _backToken;
        canAddLiquidityBeforeLaunch[_msgSender()] = true;
        canAddLiquidityBeforeLaunch[address(this)] = true;
        isFeeExempt[msg.sender] = true;
        isFeeExempt[address(this)] = true;
        factory = ICamelotFactory(_factory);
        swapRouter = ICamelotRouter(_swapRouter);
        WETH = IWETH(_weth);
        _mint(_msgSender(), _totalSupply);
    }

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

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

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

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

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

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

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

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

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

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

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

        uint256 amountDogBurn = (taxAmount * burnFee) / (totalFee);
        uint256 amountDogLp = (taxAmount * liquidityFee) / (totalFee);
        uint256 amountDogBonus = (taxAmount * bonusFee) / (totalFee);
        taxAmount -= amountDogBurn;
        taxAmount -= amountDogLp;
        taxAmount -= amountDogBonus;
        

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

        bool success = false;
        uint256 balanceBefore = backToken.balanceOf(address(this));
        try swapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(taxAmount,0,path,address(this),address(0),block.timestamp){
            success = true;
        } catch {
            try swapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(taxAmount,0,path,address(this),block.timestamp) {
                success = true;
            } 
            catch {}
        }
        if (!success) {
            return;
        }

        _transfer(address(this), DEAD, amountDogBurn);
        _approve(address(this), address(bonusWallet), amountDogBonus);
        IShibaBonusPool(bonusWallet).injectRewards(amountDogBonus);
        
        uint256 amountBackToken = backToken.balanceOf(address(this)) - balanceBefore;
        uint256 backTokenTotalFee = totalFee - burnFee - liquidityFee - bonusFee;
        uint256 amountBackTokenGov1 = (amountBackToken * gov1Fee) / (backTokenTotalFee);
        uint256 amountBackTokenGov2 = (amountBackToken * gov2Fee) / (backTokenTotalFee);
        uint256 amountBackTokenJackpot = (amountBackToken * jackpotFee) / backTokenTotalFee;
        uint256 amountBackTokenDev = amountBackToken - amountBackTokenGov1 - amountBackTokenGov2 - amountBackTokenJackpot;

        backToken.transfer(gov1Wallet, amountBackTokenGov1);
        backToken.transfer(gov2Wallet, amountBackTokenGov2);
        backToken.transfer(address(jackpotWallet), amountBackTokenJackpot);
        backToken.transfer(devWallet, amountBackTokenDev);

        if (addLiquidityEnabled) {
            _doAddLp();
        }
        
        emit SwapBack(amountDogBurn, amountBackTokenGov1, amountBackTokenGov2, amountDogLp, amountBackTokenJackpot, amountDogBonus, amountBackTokenDev, block.timestamp);
    }

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

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

        uint256 ethAmountBefore = address(this).balance;
        bool success = false;
        try swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(half,0, pathEth,address(this),address(0),block.timestamp){
            success = true;
        } catch {
            try swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(half,0, pathEth,address(this),block.timestamp){
                success = true;
            } catch {}
        }
        if (!success) {
            return;
        }

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

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

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

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

    function buyFees() internal {
        burnFee = burnFeeBuy;
        gov1Fee = gov1FeeBuy;
        gov2Fee = gov2FeeBuy;
        liquidityFee = liquidityFeeBuy;
        jackpotFee = jackpotFeeBuy;
        bonusFee = bonusFeeBuy;
        devFee = devFeeBuy;
        totalFee = totalFeeBuy;
    }

    function sellFees() internal {
        burnFee = burnFeeSell;
        gov1Fee = gov1FeeSell;
        gov2Fee = gov2FeeSell;
        liquidityFee = liquidityFeeSell;
        jackpotFee = jackpotFeeSell;
        bonusFee = bonusFeeSell;
        devFee = devFeeSell;
        totalFee = totalFeeSell;
    }

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

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

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

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

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

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

    function setBuyFees(
        uint256 _gov1Fee,
        uint256 _gov2Fee,
        uint256 _liquidityFee,
        uint256 _jackpotFee,
        uint256 _bonusFee,
        uint256 _devFee,
        uint256 _burnFee
    ) external onlyOwner {
        gov1FeeBuy = _gov1Fee;
        gov2FeeBuy = _gov2Fee;
        liquidityFeeBuy = _liquidityFee;
        jackpotFeeBuy = _jackpotFee;
        bonusFeeBuy = _bonusFee;
        devFeeBuy = _devFee;
        burnFeeBuy = _burnFee;
        totalFeeBuy = _liquidityFee + _jackpotFee + _bonusFee + _devFee + _burnFee;
    }

    function setSellFees(
        uint256 _gov1Fee,
        uint256 _gov2Fee,
        uint256 _liquidityFee,
        uint256 _jackpotFee,
        uint256 _bonusFee,
        uint256 _devFee,
        uint256 _burnFee
    ) external onlyOwner {
        gov1FeeSell = _gov1Fee;
        gov2FeeSell = _gov2Fee;
        liquidityFeeSell = _liquidityFee;
        jackpotFeeSell = _jackpotFee;
        bonusFeeSell = _bonusFee;
        devFeeSell = _devFee;
        burnFeeSell = _burnFee;
        totalFeeSell = _liquidityFee + _jackpotFee + _bonusFee + _devFee + _burnFee;
    }

    function setFeeReceivers(
        address _gov1Wallet,
        address _gov2Wallet,
        address _bonusWallet,
        address _jackpotWallet,
        address _devWallet
    ) external onlyOwner {
        gov1Wallet = _gov1Wallet;
        gov2Wallet = _gov2Wallet;
        bonusWallet = _bonusWallet;
        jackpotWallet = IJackpot(_jackpotWallet);
        devWallet = _devWallet;
        devWallet = _devWallet;
    }

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

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

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

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

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

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

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

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

    receive() external payable {}
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"contract IERC20","name":"_backToken","type":"address"},{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_swapRouter","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AddLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"burn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gov1","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gov2","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"liquidity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"jackpot","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"bonus","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dev","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"SwapBack","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"side","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"circulatingSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Trade","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"addLiquidityEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"addPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"backToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"canAddLiquidityBeforeLaunch","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clearStuckBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"clearStuckEthBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"delPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"doSwapBack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCirculatingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinterLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov1Fee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov1FeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov1FeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov2Fee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov2FeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov2FeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inSwap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initializePair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"jackpotFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"jackpotFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"jackpotWallet","outputs":[{"internalType":"contract IJackpot","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"launchedAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launchedAtTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"rescueToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setAddLiquidityEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gov1Fee","type":"uint256"},{"internalType":"uint256","name":"_gov2Fee","type":"uint256"},{"internalType":"uint256","name":"_liquidityFee","type":"uint256"},{"internalType":"uint256","name":"_jackpotFee","type":"uint256"},{"internalType":"uint256","name":"_bonusFee","type":"uint256"},{"internalType":"uint256","name":"_devFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"}],"name":"setBuyFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_gov1Wallet","type":"address"},{"internalType":"address","name":"_gov2Wallet","type":"address"},{"internalType":"address","name":"_bonusWallet","type":"address"},{"internalType":"address","name":"_jackpotWallet","type":"address"},{"internalType":"address","name":"_devWallet","type":"address"}],"name":"setFeeReceivers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gov1Fee","type":"uint256"},{"internalType":"uint256","name":"_gov2Fee","type":"uint256"},{"internalType":"uint256","name":"_liquidityFee","type":"uint256"},{"internalType":"uint256","name":"_jackpotFee","type":"uint256"},{"internalType":"uint256","name":"_bonusFee","type":"uint256"},{"internalType":"uint256","name":"_devFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"}],"name":"setSellFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setSwapBackSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

000000000000000000000000912ce59144191c1204e64559fe8253a0e49e65480000000000000000000000006eccab422d763ac031210895c81787e87b43a652000000000000000000000000c873fecbd354f5a56e00e710b90ef4201db2448d00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1

-----Decoded View---------------
Arg [0] : _backToken (address): 0x912CE59144191C1204E64559FE8253a0e49E6548
Arg [1] : _factory (address): 0x6EcCab422D763aC031210895C81787E87B43A652
Arg [2] : _swapRouter (address): 0xc873fEcbd354f5A56E00E710B90EF4201db2448d
Arg [3] : _weth (address): 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000912ce59144191c1204e64559fe8253a0e49e6548
Arg [1] : 0000000000000000000000006eccab422d763ac031210895c81787e87b43a652
Arg [2] : 000000000000000000000000c873fecbd354f5a56e00e710b90ef4201db2448d
Arg [3] : 00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1

Deployed Bytecode Sourcemap

56929:13981:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67913:182;;;;;;;;;;;;;:::i;:::-;;57788:22;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;57788:22:0;;;;;;;;70581:98;;;;;;;;;;;;;:::i;6739:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;9090:201::-;;;;;;;;;;-1:-1:-1;9090:201:0;;;;;:::i;:::-;;:::i;:::-;;;1473:14:1;;1466:22;1448:41;;1436:2;1421:18;9090:201:0;1308:187:1;68103:576:0;;;;;;;;;;-1:-1:-1;68103:576:0;;;;;:::i;:::-;;:::i;58488:37::-;;;;;;;;;;;;;;;;58614:31;;;;;;;;;;;;;;;;58039;;;;;;;;;;;;;;;;57976:37;;;;;;;;;;;;;;;;7859:108;;;;;;;;;;-1:-1:-1;7947:12:0;;7859:108;;69280:436;;;;;;;;;;-1:-1:-1;69280:436:0;;;;;:::i;:::-;;:::i;58371:32::-;;;;;;;;;;;;;;;;60513:269;;;;;;;;;;-1:-1:-1;60513:269:0;;;;;:::i;:::-;;:::i;67737:137::-;;;;;;;;;;;;;:::i;58818:29::-;;;;;;;;;;-1:-1:-1;58818:29:0;;;;-1:-1:-1;;;;;58818:29:0;;;;;;-1:-1:-1;;;;;3557:32:1;;;3539:51;;3527:2;3512:18;58818:29:0;3376:220:1;60256:92:0;;;;;;;;;;-1:-1:-1;60256:92:0;;60339:1;3743:36:1;;3731:2;3716:18;60256:92:0;3601:184:1;67594:135:0;;;;;;;;;;;;;:::i;10575:238::-;;;;;;;;;;-1:-1:-1;10575:238:0;;;;;:::i;:::-;;:::i;57611:43::-;;;;;;;;;;-1:-1:-1;57611:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;67149:172;;;;;;;;;;-1:-1:-1;67149:172:0;;;;;:::i;:::-;;:::i;60010:238::-;;;;;;;;;;;;;:::i;58652:34::-;;;;;;;;;;;;;;;;69724:119;;;;;;;;;;-1:-1:-1;69724:119:0;;;;;:::i;:::-;;:::i;58196:34::-;;;;;;;;;;;;;;;;57405:30;;;;;;;;;;-1:-1:-1;57405:30:0;;;;-1:-1:-1;;;57405:30:0;;;;;;8030:127;;;;;;;;;;-1:-1:-1;8030:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;8131:18:0;8104:7;8131:18;;;;;;;;;;;;8030:127;58077:31;;;;;;;;;;;;;;;;36095:103;;;;;;;;;;;;;:::i;57661:59::-;;;;;;;;;;-1:-1:-1;57661:59:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;58153:36;;;;;;;;;;;;;;;;57442:38;;;;;;;;;;-1:-1:-1;57442:38:0;;;;-1:-1:-1;;;57442:38:0;;;;;;58888:23;;;;;;;;;;-1:-1:-1;58888:23:0;;;;-1:-1:-1;;;;;58888:23:0;;;58237:32;;;;;;;;;;;;;;;;35447:87;;;;;;;;;;-1:-1:-1;35520:6:0;;-1:-1:-1;;;;;35520:6:0;35447:87;;66097:68;;;;;;;;;;;;;:::i;68687:585::-;;;;;;;;;;-1:-1:-1;68687:585:0;;;;;:::i;:::-;;:::i;6958:104::-;;;;;;;;;;;;;:::i;11316:436::-;;;;;;;;;;-1:-1:-1;11316:436:0;;;;;:::i;:::-;;:::i;70391:182::-;;;;;;;;;;-1:-1:-1;70391:182:0;;;;;:::i;:::-;;:::i;60356:149::-;;;;;;;;;;-1:-1:-1;60356:149:0;;;;;:::i;:::-;;:::i;69963:115::-;;;;;;;;;;-1:-1:-1;69963:115:0;;;;;:::i;:::-;;:::i;58574:33::-;;;;;;;;;;;;;;;;58449:32;;;;;;;;;;;;;;;;58532:35;;;;;;;;;;;;;;;;69851:104;;;;;;;;;;-1:-1:-1;69851:104:0;;;;;:::i;:::-;;:::i;70687:183::-;;;;;;;;;;-1:-1:-1;70687:183:0;;;;;:::i;:::-;;:::i;58918:25::-;;;;;;;;;;;;;;;;67329:257;;;;;;;;;;;;;:::i;70204:179::-;;;;;;;;;;-1:-1:-1;70204:179:0;;;;;:::i;:::-;;:::i;58950:34::-;;;;;;;;;;;;;;;;57759:22;;;;;;;;;;;;;;;;58276:30;;;;;;;;;;;;;;;;57489:18;;;;;;;;;;-1:-1:-1;57489:18:0;;;;-1:-1:-1;;;57489:18:0;;;;;;58410:32;;;;;;;;;;;;;;;;8619:151;;;;;;;;;;-1:-1:-1;8619:151:0;;;;;:::i;:::-;;:::i;58115:31::-;;;;;;;;;;;;;;;;70086:110;;;;;;;;;;-1:-1:-1;70086:110:0;;;;;:::i;:::-;;:::i;36353:201::-;;;;;;;;;;-1:-1:-1;36353:201:0;;;;;:::i;:::-;;:::i;58313:33::-;;;;;;;;;;;;;;;;67913:182;35333:13;:11;:13::i;:::-;67967:10:::1;::::0;:15;67959:44:::1;;;::::0;-1:-1:-1;;;67959:44:0;;6007:2:1;67959:44:0::1;::::0;::::1;5989:21:1::0;6046:2;6026:18;;;6019:30;-1:-1:-1;;;6065:18:1;;;6058:46;6121:18;;67959:44:0::1;;;;;;;;;68027:12;68014:10;:25:::0;68072:15:::1;68050:19;:37:::0;67913:182::o;70581:98::-;70629:7;70656:15;:6;:13;:15::i;:::-;70649:22;;70581:98;:::o;6739:100::-;6793:13;6826:5;6819:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6739:100;:::o;9090:201::-;9173:4;4465:10;9229:32;4465:10;9245:7;9254:6;9229:8;:32::i;:::-;9279:4;9272:11;;;9090:201;;;;;:::o;68103:576::-;35333:13;:11;:13::i;:::-;68357:10:::1;:21:::0;;;68389:10:::1;:21:::0;;;68421:15:::1;:31:::0;;;68463:13:::1;:27:::0;;;68501:11:::1;:23:::0;;;68535:9:::1;:19:::0;;;68565:10:::1;:21:::0;;;68578:8;68547:7;68515:9;68611:27:::1;68479:11:::0;68439:13;68611:27:::1;:::i;:::-;:39;;;;:::i;:::-;:49;;;;:::i;:::-;:60;;;;:::i;:::-;68597:11;:74:::0;-1:-1:-1;;;;;;;68103:576:0:o;69280:436::-;35333:13;:11;:13::i;:::-;69495:10:::1;:24:::0;;-1:-1:-1;;;;;;69495:24:0;;::::1;-1:-1:-1::0;;;;;69495:24:0;;::::1;;::::0;;;69530:10:::1;:24:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;69565:11:::1;:26:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;69602:13:::1;:40:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;69653:9:::1;:22:::0;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;69280:436::o;60513:269::-;60619:4;4465:10;60677:40;60693:6;4465:10;60710:6;60677:15;:40::i;:::-;60735:39;60748:6;60756:9;60767:6;60735:12;:39::i;:::-;60728:46;;;60513:269;;;;;;:::o;67737:137::-;67790:7;8131:18;;;;;;59189:42;8131:18;;;;7947:12;;67817:31;;8131:18;67817:31;:::i;:::-;:49;;;;:::i;67594:135::-;35333:13;:11;:13::i;:::-;67653:9:::1;::::0;-1:-1:-1;;;;;67653:9:0::1;:18;4465:10:::0;67686:9:::1;::::0;:34:::1;::::0;-1:-1:-1;;;67686:34:0;;67714:4:::1;67686:34;::::0;::::1;3539:51:1::0;-1:-1:-1;;;;;67686:9:0;;::::1;::::0;:19:::1;::::0;3512:18:1;;67686:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67653:68;::::0;-1:-1:-1;;;;;;67653:68:0::1;::::0;;;;;;-1:-1:-1;;;;;7311:32:1;;;67653:68:0::1;::::0;::::1;7293:51:1::0;7360:18;;;7353:34;7266:18;;67653:68:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;67594:135::o:0;10575:238::-;10663:4;4465:10;10719:64;4465:10;10735:7;10772:10;10744:25;4465:10;10735:7;10744:9;:25::i;:::-;:38;;;;:::i;:::-;10719:8;:64::i;67149:172::-;35333:13;:11;:13::i;:::-;67267:45:::1;::::0;-1:-1:-1;;;67267:45:0;;67306:4:::1;67267:45;::::0;::::1;3539:51:1::0;67222:91:0::1;::::0;67256:10:::1;::::0;-1:-1:-1;;;;;67267:30:0;::::1;::::0;::::1;::::0;3512:18:1;;67267:45:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;67222:33:0;::::1;::::0;:91;:33:::1;:91::i;60010:238::-:0;35333:13;:11;:13::i;:::-;60075:11:::1;::::0;::::1;;60074:12;60066:44;;;::::0;-1:-1:-1;;;60066:44:0;;7850:2:1;60066:44:0::1;::::0;::::1;7832:21:1::0;7889:2;7869:18;;;7862:30;-1:-1:-1;;;7908:18:1;;;7901:49;7967:18;;60066:44:0::1;7648:343:1::0;60066:44:0::1;60136:48;::::0;-1:-1:-1;;;60136:48:0;;-1:-1:-1;;;;;60163:4:0::1;8226:15:1::0;;60136:48:0::1;::::0;::::1;8208:34:1::0;60178:4:0::1;8258:18:1::0;;;8251:43;-1:-1:-1;;60136:7:0::1;:18:::0;;::::1;::::0;::::1;::::0;8143::1;;60136:48:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60121:63:::0;-1:-1:-1;60195:16:0::1;:6;60121:63:::0;60195:10:::1;:16::i;:::-;-1:-1:-1::0;;60222:11:0::1;:18:::0;;-1:-1:-1;;60222:18:0::1;60236:4;60222:18;::::0;;60010:238::o;69724:119::-;35333:13;:11;:13::i;:::-;-1:-1:-1;;;;;69807:19:0;;;::::1;;::::0;;;:11:::1;:19;::::0;;;;:28;;-1:-1:-1;;69807:28:0::1;::::0;::::1;;::::0;;;::::1;::::0;;69724:119::o;36095:103::-;35333:13;:11;:13::i;:::-;36160:30:::1;36187:1;36160:18;:30::i;:::-;36095:103::o:0;66097:68::-;35333:13;:11;:13::i;:::-;66147:10:::1;:8;:10::i;68687:585::-:0;35333:13;:11;:13::i;:::-;68942:11:::1;:22:::0;;;68975:11:::1;:22:::0;;;69008:16:::1;:32:::0;;;69051:14:::1;:28:::0;;;69090:12:::1;:24:::0;;;69125:10:::1;:20:::0;;;69156:11:::1;:22:::0;;;69170:8;69138:7;69105:9;69204:27:::1;69068:11:::0;69027:13;69204:27:::1;:::i;:::-;:39;;;;:::i;:::-;:49;;;;:::i;:::-;:60;;;;:::i;:::-;69189:12;:75:::0;-1:-1:-1;;;;;;;68687:585:0:o;6958:104::-;7014:13;7047:7;7040:14;;;;;:::i;11316:436::-;11409:4;4465:10;11409:4;11492:25;4465:10;11509:7;11492:9;:25::i;:::-;11465:52;;11556:15;11536:16;:35;;11528:85;;;;-1:-1:-1;;;11528:85:0;;8763:2:1;11528:85:0;;;8745:21:1;8802:2;8782:18;;;8775:30;8841:34;8821:18;;;8814:62;-1:-1:-1;;;8892:18:1;;;8885:35;8937:19;;11528:85:0;8561:401:1;11528:85:0;11649:60;11658:5;11665:7;11693:15;11674:16;:34;11649:8;:60::i;:::-;-1:-1:-1;11740:4:0;;11316:436;-1:-1:-1;;;;11316:436:0:o;70391:182::-;70448:4;35333:13;:11;:13::i;:::-;-1:-1:-1;;;;;70473:18:0;::::1;70465:63;;;::::0;-1:-1:-1;;;70465:63:0;;9169:2:1;70465:63:0::1;::::0;::::1;9151:21:1::0;;;9188:18;;;9181:30;9247:34;9227:18;;;9220:62;9299:18;;70465:63:0::1;8967:356:1::0;70465:63:0::1;70546:19;:6;70560:4:::0;70546:13:::1;:19::i;60356:149::-:0;60435:4;60459:38;4465:10;60486:2;60490:6;60459:12;:38::i;69963:115::-;35333:13;:11;:13::i;:::-;70040:19:::1;:30:::0;;;::::1;;-1:-1:-1::0;;;70040:30:0::1;-1:-1:-1::0;;;;70040:30:0;;::::1;::::0;;;::::1;::::0;;69963:115::o;69851:104::-;35333:13;:11;:13::i;:::-;69925:11:::1;:22:::0;;;::::1;;-1:-1:-1::0;;;69925:22:0::1;-1:-1:-1::0;;;;69925:22:0;;::::1;::::0;;;::::1;::::0;;69851:104::o;70687:183::-;70740:7;70795:1;70777:15;:6;:13;:15::i;:::-;:19;;;;:::i;:::-;70768:5;:28;;70760:68;;;;-1:-1:-1;;;70760:68:0;;9530:2:1;70760:68:0;;;9512:21:1;9569:2;9549:18;;;9542:30;9608:29;9588:18;;;9581:57;9655:18;;70760:68:0;9328:351:1;70760:68:0;70846:16;:6;70856:5;70846:9;:16::i;67329:257::-;35333:13;:11;:13::i;:::-;67507:12:::1;::::0;;67391:17:::1;67507:12:::0;;;::::1;::::0;::::1;::::0;;;;67411:21:::1;::::0;67391:17;;4465:10;;67411:21;;67462:58:::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67443:77;;;67539:7;67531:47;;;::::0;-1:-1:-1;;;67531:47:0;;10310:2:1;67531:47:0::1;::::0;::::1;10292:21:1::0;10349:2;10329:18;;;10322:30;10388:29;10368:18;;;10361:57;10435:18;;67531:47:0::1;10108:351:1::0;67531:47:0::1;67380:206;;67329:257::o:0;70204:179::-;70261:4;35333:13;:11;:13::i;:::-;-1:-1:-1;;;;;70286:18:0;::::1;70278:63;;;::::0;-1:-1:-1;;;70278:63:0;;9169:2:1;70278:63:0::1;::::0;::::1;9151:21:1::0;;;9188:18;;;9181:30;9247:34;9227:18;;;9220:62;9299:18;;70278:63:0::1;8967:356:1::0;70278:63:0::1;70359:16;:6;70370:4:::0;70359:10:::1;:16::i;8619:151::-:0;-1:-1:-1;;;;;8735:18:0;;;8708:7;8735:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8619:151::o;70086:110::-;70140:4;70164:24;:6;70180:7;70164:15;:24::i;36353:201::-;35333:13;:11;:13::i;:::-;-1:-1:-1;;;;;36442:22:0;::::1;36434:73;;;::::0;-1:-1:-1;;;36434:73:0;;10666:2:1;36434:73:0::1;::::0;::::1;10648:21:1::0;10705:2;10685:18;;;10678:30;10744:34;10724:18;;;10717:62;-1:-1:-1;;;10795:18:1;;;10788:36;10841:19;;36434:73:0::1;10464:402:1::0;36434:73:0::1;36518:28;36537:8;36518:18;:28::i;35612:132::-:0;35520:6;;-1:-1:-1;;;;;35520:6:0;4465:10;35676:23;35668:68;;;;-1:-1:-1;;;35668:68:0;;11073:2:1;35668:68:0;;;11055:21:1;;;11092:18;;;11085:30;11151:34;11131:18;;;11124:62;11203:18;;35668:68:0;10871:356:1;46311:117:0;46374:7;46401:19;46409:3;41611:18;;41528:109;15343:380;-1:-1:-1;;;;;15479:19:0;;15471:68;;;;-1:-1:-1;;;15471:68:0;;11434:2:1;15471:68:0;;;11416:21:1;11473:2;11453:18;;;11446:30;11512:34;11492:18;;;11485:62;-1:-1:-1;;;11563:18:1;;;11556:34;11607:19;;15471:68:0;11232:400:1;15471:68:0;-1:-1:-1;;;;;15558:21:0;;15550:68;;;;-1:-1:-1;;;15550:68:0;;11839:2:1;15550:68:0;;;11821:21:1;11878:2;11858:18;;;11851:30;11917:34;11897:18;;;11890:62;-1:-1:-1;;;11968:18:1;;;11961:32;12010:19;;15550:68:0;11637:398:1;15550:68:0;-1:-1:-1;;;;;15631:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;15683:32;;160:25:1;;;15683:32:0;;133:18:1;15683:32:0;;;;;;;15343:380;;;:::o;16014:453::-;16149:24;16176:25;16186:5;16193:7;16176:9;:25::i;:::-;16149:52;;-1:-1:-1;;16216:16:0;:37;16212:248;;16298:6;16278:16;:26;;16270:68;;;;-1:-1:-1;;;16270:68:0;;12242:2:1;16270:68:0;;;12224:21:1;12281:2;12261:18;;;12254:30;12320:31;12300:18;;;12293:59;12369:18;;16270:68:0;12040:353:1;16270:68:0;16382:51;16391:5;16398:7;16426:6;16407:16;:25;16382:8;:51::i;:::-;16138:329;16014:453;;;:::o;60790:1278::-;60902:6;;60881:4;;-1:-1:-1;;;60902:6:0;;;;60898:101;;;60925:36;60935:6;60943:9;60954:6;60925:9;:36::i;:::-;-1:-1:-1;60983:4:0;60976:11;;60898:101;-1:-1:-1;;;;;61014:35:0;;;;;;:27;:35;;;;;;;;61009:112;;66240:10;;61066:43;;;;-1:-1:-1;;;61066:43:0;;12600:2:1;61066:43:0;;;12582:21:1;12639:2;12619:18;;;12612:30;-1:-1:-1;;;12658:18:1;;;12651:50;12718:18;;61066:43:0;12398:344:1;61066:43:0;-1:-1:-1;;;;;61156:19:0;;61133:18;61156:19;;;:11;:19;;;;;;;;61155:20;:47;;;;-1:-1:-1;;;;;;61180:22:0;;;;;;:11;:22;;;;;;;;61179:23;61155:47;61154:63;;;;-1:-1:-1;66240:10:0;;:15;;61207:10;61133:84;-1:-1:-1;61228:9:0;61268:6;61301:9;61346:14;61268:6;61346;:14::i;:::-;61342:353;;;61377:9;66320:10;;66310:7;:20;66351:10;;-1:-1:-1;66341:20:0;66382:10;;66372:7;:20;66418:15;;66403:12;:30;66457:13;;66444:10;:26;66492:11;;66481:8;:22;66523:9;;66514:6;:18;66554:11;;66543:8;:22;66271:302;61377:9;-1:-1:-1;;61489:13:0;;;:40;;-1:-1:-1;;;61489:40:0;;-1:-1:-1;;;;;7311:32:1;;;61489:40:0;;;7293:51:1;7360:18;;;7353:34;;;61408:1:0;;-1:-1:-1;61432:9:0;;61464:6;;61489:13;;:24;;7266:18:1;;61489:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61485:56;61342:353;61485:56;61342:353;;;61562:17;61569:9;61562:6;:17::i;:::-;61558:137;;;61596:10;66631:11;;66621:7;:21;66663:11;;66653:7;:21;66695:11;;66685:7;:21;66732:16;;66717:12;:31;66772:14;;66759:10;:27;66808:12;;-1:-1:-1;66797:23:0;66840:10;;-1:-1:-1;66831:19:0;66872:12;;-1:-1:-1;66861:23:0;66581:311;61596:10;61628:1;61621:8;;61558:137;;;61678:5;61662:21;;61558:137;61711:16;:14;:16::i;:::-;61707:59;;;61744:10;:8;:10::i;:::-;61778:22;61803:13;:48;;61845:6;61803:48;;;61819:23;61827:6;61835;61819:7;:23::i;:::-;61778:73;;61862:44;61872:6;61880:9;61891:14;61862:9;:44::i;:::-;61923:8;;61919:120;;61953:74;61959:5;61966;61973:6;61981:4;61987:22;:20;:22::i;:::-;61953:74;;;-1:-1:-1;;;;;13090:15:1;;;13072:34;;13142:15;;;;13137:2;13122:18;;13115:43;13174:18;;;13167:34;;;;13232:2;13217:18;;13210:34;13275:3;13260:19;;13253:35;62011:15:0;13052:3:1;13304:19;;13297:35;13021:3;13006:19;61953:74:0;;;;;;;61919:120;-1:-1:-1;62056:4:0;;60790:1278;-1:-1:-1;;;;;;;;60790:1278:0:o;30426:211::-;30570:58;;;-1:-1:-1;;;;;7311:32:1;;30570:58:0;;;7293:51:1;7360:18;;;;7353:34;;;30570:58:0;;;;;;;;;;7266:18:1;;;;30570:58:0;;;;;;;;-1:-1:-1;;;;;30570:58:0;-1:-1:-1;;;30570:58:0;;;30543:86;;30563:5;;30543:19;:86::i;:::-;30426:211;;;:::o;45486:152::-;45556:4;45580:50;45585:3;-1:-1:-1;;;;;45605:23:0;;45580:4;:50::i;36714:191::-;36807:6;;;-1:-1:-1;;;;;36824:17:0;;;-1:-1:-1;;;;;;36824:17:0;;;;;;;36857:40;;36807:6;;;36824:17;36807:6;;36857:40;;36788:16;;36857:40;36777:128;36714:191;:::o;62258:2515::-;57545:6;:13;;-1:-1:-1;;;;57545:13:0;-1:-1:-1;;;57545:13:0;;;62345:4:::1;-1:-1:-1::0;8131:18:0;;;;;;;;;;;62307:44:::1;;62362:55;62379:4;62394:10;62407:9;62362:8;:55::i;:::-;62430:21;62479:8;;62467:7;;62455:9;:19;;;;:::i;:::-;62454:34;;;;:::i;:::-;62430:58;;62499:19;62551:8;;62534:12;;62522:9;:24;;;;:::i;:::-;62521:39;;;;:::i;:::-;62499:61;;62571:22;62622:8;;62609;;62597:9;:20;;;;:::i;:::-;62596:35;;;;:::i;:::-;62571:60:::0;-1:-1:-1;62642:26:0::1;62655:13:::0;62642:26;::::1;:::i;:::-;::::0;-1:-1:-1;62679:24:0::1;62692:11:::0;62642:26;62679:24:::1;:::i;:::-;::::0;-1:-1:-1;62714:27:0::1;62727:14:::0;62679:24;62714:27:::1;:::i;:::-;62788:16;::::0;;62802:1:::1;62788:16:::0;;;;;::::1;::::0;;;62714:27;;-1:-1:-1;62764:21:0::1;::::0;62788:16;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;62788:16:0::1;62764:40;;62833:4;62815;62820:1;62815:7;;;;;;;;:::i;:::-;;;;;;:23;-1:-1:-1::0;;;;;62815:23:0::1;;;-1:-1:-1::0;;;;;62815:23:0::1;;;::::0;::::1;62867:4;62849;62854:1;62849:7;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;62849:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;62901:9:::1;::::0;62883:7;;62901:9;::::1;::::0;62883:4;;62888:1:::1;::::0;62883:7;::::1;;;;;:::i;:::-;-1:-1:-1::0;;;;;62883:28:0;;::::1;:7;::::0;;::::1;::::0;;;;;:28;62979:9:::1;::::0;:34:::1;::::0;-1:-1:-1;;;62979:34:0;;63007:4:::1;62979:34;::::0;::::1;3539:51:1::0;62924:12:0::1;::::0;;;62979:9:::1;::::0;:19:::1;::::0;3512:18:1;;62979:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63028:123;::::0;-1:-1:-1;;;63028:123:0;;62955:58;;-1:-1:-1;;;;;;63028:10:0::1;:64;::::0;::::1;::::0;:123:::1;::::0;63093:9;;63103:1:::1;::::0;63105:4;;63118::::1;::::0;63103:1;;63135:15:::1;::::0;63028:123:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;63024:390;;63218:112;::::0;-1:-1:-1;;;63218:112:0;;-1:-1:-1;;;;;63218:10:0::1;:64;::::0;::::1;::::0;:112:::1;::::0;63283:9;;63293:1:::1;::::0;63295:4;;63308::::1;::::0;63314:15:::1;::::0;63218:112:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;63214:189:::0;::::1;;63360:4;63350:14;;63214:189;63024:390;;;63176:4;63166:14;;63024:390;63429:7;63424:47;;63453:7;;;;;;;;;63424:47;63483:45;63501:4;59189:42;63514:13;63483:9;:45::i;:::-;63571:11;::::0;63539:61:::1;::::0;63556:4:::1;::::0;-1:-1:-1;;;;;63571:11:0::1;63585:14:::0;63539:8:::1;:61::i;:::-;63627:11;::::0;63611:58:::1;::::0;-1:-1:-1;;;63611:58:0;;::::1;::::0;::::1;160:25:1::0;;;-1:-1:-1;;;;;63627:11:0;;::::1;::::0;63611:42:::1;::::0;133:18:1;;63611:58:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;63716:9:0::1;::::0;:34:::1;::::0;-1:-1:-1;;;63716:34:0;;63744:4:::1;63716:34;::::0;::::1;3539:51:1::0;63690:23:0::1;::::0;-1:-1:-1;63753:13:0;;-1:-1:-1;;;;;;63716:9:0;;::::1;::::0;:19:::1;::::0;3512:18:1;;63716:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;;;:::i;:::-;63690:76;;63777:25;63841:8;;63826:12;;63816:7;;63805:8;;:18;;;;:::i;:::-;:33;;;;:::i;:::-;:44;;;;:::i;:::-;63777:72;;63860:27;63921:17;63909:7;;63891:15;:25;;;;:::i;:::-;63890:49;;;;:::i;:::-;63860:79;;63950:27;64011:17;63999:7;;63981:15;:25;;;;:::i;:::-;63980:49;;;;:::i;:::-;63950:79;;64040:30;64106:17;64092:10;;64074:15;:28;;;;:::i;:::-;64073:50;;;;:::i;:::-;64040:83:::0;-1:-1:-1;64134:26:0::1;64040:83:::0;64203:19;64163:37:::1;64181:19:::0;64163:15;:37:::1;:::i;:::-;:59;;;;:::i;:::-;:84;;;;:::i;:::-;64260:9;::::0;64279:10:::1;::::0;64260:51:::1;::::0;-1:-1:-1;;;64260:51:0;;-1:-1:-1;;;;;64279:10:0;;::::1;64260:51;::::0;::::1;7293::1::0;7360:18;;;7353:34;;;64134:113:0;;-1:-1:-1;64260:9:0::1;::::0;:18:::1;::::0;7266::1;;64260:51:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;64322:9:0::1;::::0;64341:10:::1;::::0;64322:51:::1;::::0;-1:-1:-1;;;64322:51:0;;-1:-1:-1;;;;;64341:10:0;;::::1;64322:51;::::0;::::1;7293::1::0;7360:18;;;7353:34;;;64322:9:0;::::1;::::0;:18:::1;::::0;7266::1;;64322:51:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;64384:9:0::1;::::0;64411:13:::1;::::0;;64384:66:::1;::::0;-1:-1:-1;;;64384:66:0;;-1:-1:-1;;;;;64411:13:0;;::::1;64384:66;::::0;::::1;7293:51:1::0;7360:18;;;7353:34;;;64384:9:0;;::::1;::::0;:18:::1;::::0;7266::1;;64384:66:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;64461:9:0::1;::::0;64480::::1;::::0;64461:49:::1;::::0;-1:-1:-1;;;64461:49:0;;-1:-1:-1;;;;;64480:9:0;;::::1;64461:49;::::0;::::1;7293:51:1::0;7360:18;;;7353:34;;;64461:9:0;::::1;::::0;:18:::1;::::0;7266::1;;64461:49:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;64527:19:0::1;::::0;-1:-1:-1;;;64527:19:0;::::1;;;64523:62;;;64563:10;:8;:10::i;:::-;64610:155;::::0;;15955:25:1;;;16011:2;15996:18;;15989:34;;;16039:18;;;16032:34;;;16097:2;16082:18;;16075:34;;;16140:3;16125:19;;16118:35;;;16184:3;16169:19;;16162:35;;;16228:3;16213:19;;16206:35;;;64749:15:0::1;16272:3:1::0;16257:19;;16250:35;64610:155:0::1;::::0;15942:3:1;15927:19;64610:155:0::1;;;;;;;62296:2477;;;;;;;;;;;;;57569:1;57581:6:::0;:14;;-1:-1:-1;;;;57581:14:0;;;62258:2515::o;45814:158::-;45887:4;45911:53;45919:3;-1:-1:-1;;;;;45939:23:0;;45911:7;:53::i;46782:158::-;46856:7;46907:22;46911:3;46923:5;46907:3;:22::i;46058:167::-;-1:-1:-1;;;;;46192:23:0;;46138:4;41410:19;;;:12;;;:19;;;;;;:24;;46162:55;41313:129;12222:840;-1:-1:-1;;;;;12353:18:0;;12345:68;;;;-1:-1:-1;;;12345:68:0;;16498:2:1;12345:68:0;;;16480:21:1;16537:2;16517:18;;;16510:30;16576:34;16556:18;;;16549:62;-1:-1:-1;;;16627:18:1;;;16620:35;16672:19;;12345:68:0;16296:401:1;12345:68:0;-1:-1:-1;;;;;12432:16:0;;12424:64;;;;-1:-1:-1;;;12424:64:0;;16904:2:1;12424:64:0;;;16886:21:1;16943:2;16923:18;;;16916:30;16982:34;16962:18;;;16955:62;-1:-1:-1;;;17033:18:1;;;17026:33;17076:19;;12424:64:0;16702:399:1;12424:64:0;-1:-1:-1;;;;;12574:15:0;;12552:19;12574:15;;;;;;;;;;;12608:21;;;;12600:72;;;;-1:-1:-1;;;12600:72:0;;17308:2:1;12600:72:0;;;17290:21:1;17347:2;17327:18;;;17320:30;17386:34;17366:18;;;17359:62;-1:-1:-1;;;17437:18:1;;;17430:36;17483:19;;12600:72:0;17106:402:1;12600:72:0;-1:-1:-1;;;;;12708:15:0;;;:9;:15;;;;;;;;;;;12726:20;;;12708:38;;12926:13;;;;;;;;;;:23;;;;;;12978:26;;160:25:1;;;12926:13:0;;12978:26;;133:18:1;12978:26:0;;;;;;;13017:37;30426:211;62076:174;62150:6;;62125:4;;-1:-1:-1;;;62150:6:0;;;;62149:7;:22;;;;-1:-1:-1;62160:11:0;;-1:-1:-1;;;62160:11:0;;;;62149:22;:36;;;;-1:-1:-1;66240:10:0;;:15;;62175:10;62149:68;;;;-1:-1:-1;62207:4:0;62216:1;8131:18;;;;;;;;;;;62189:28;62149:68;:93;;;;-1:-1:-1;62222:20:0;4465:10;70086:110;:::i;62222:20::-;62221:21;62142:100;;62076:174;:::o;66900:241::-;66967:7;66987:17;67029:14;;67017:8;;67008:6;:17;;;;:::i;:::-;67007:36;;;;:::i;:::-;66987:56;;67054:43;67064:6;67080:4;67087:9;67054;:43::i;:::-;67115:18;67124:9;67115:6;:18;:::i;:::-;67108:25;66900:241;-1:-1:-1;;;;66900:241:0:o;33493:716::-;33917:23;33943:69;33971:4;33943:69;;;;;;;;;;;;;;;;;33951:5;-1:-1:-1;;;;;33943:27:0;;;:69;;;;;:::i;:::-;34027:17;;33917:95;;-1:-1:-1;34027:21:0;34023:179;;34124:10;34113:30;;;;;;;;;;;;:::i;:::-;34105:85;;;;-1:-1:-1;;;34105:85:0;;17715:2:1;34105:85:0;;;17697:21:1;17754:2;17734:18;;;17727:30;17793:34;17773:18;;;17766:62;-1:-1:-1;;;17844:18:1;;;17837:40;17894:19;;34105:85:0;17513:406:1;39217:414:0;39280:4;41410:19;;;:12;;;:19;;;;;;39297:327;;-1:-1:-1;39340:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;39523:18;;39501:19;;;:12;;;:19;;;;;;:40;;;;39556:11;;39297:327;-1:-1:-1;39607:5:0;39600:12;;64781:936;64848:16;;;64862:1;64848:16;;;;;;;;64821:24;;64848:16;;;;;;;;;;-1:-1:-1;64848:16:0;64821:43;;64896:4;64875:7;64883:1;64875:10;;;;;;;;:::i;:::-;;;;;;:26;-1:-1:-1;;;;;64875:26:0;;;-1:-1:-1;;;;;64875:26:0;;;;;64933:4;64912:7;64920:1;64912:10;;;;;;;;:::i;:::-;-1:-1:-1;;;;;64912:26:0;;;;:10;;;;;;;;;;:26;64991:4;64951:19;8131:18;;;;;;;;;;;;65023:15;65037:1;8131:18;65023:15;:::i;:::-;65008:30;;65059:4;65052;:11;65049:23;;;65065:7;;;64781:936::o;65049:23::-;65177:119;;-1:-1:-1;;;65177:119:0;;65110:21;;65084:23;;-1:-1:-1;;;;;65177:10:0;:61;;;;:119;;65239:4;;65084:23;;65247:7;;65263:4;;65084:23;;65280:15;;65177:119;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65173:367;;65363:108;;-1:-1:-1;;;65363:108:0;;-1:-1:-1;;;;;65363:10:0;:61;;;;:108;;65425:4;;65430:1;;65433:7;;65449:4;;65455:15;;65363:108;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65359:170;;;-1:-1:-1;65500:4:0;65359:170;65173:367;;;-1:-1:-1;65321:4:0;65173:367;65555:7;65550:47;;65579:7;;;;;64781:936::o;65550:47::-;65609:17;65629:39;65653:15;65629:21;:39;:::i;:::-;65609:59;;65679:30;65693:4;65699:9;65679:13;:30::i;:::-;64810:907;;;;;;64781:936::o;39807:1420::-;39873:4;40012:19;;;:12;;;:19;;;;;;40048:15;;40044:1176;;40423:21;40447:14;40460:1;40447:10;:14;:::i;:::-;40496:18;;40423:38;;-1:-1:-1;40476:17:0;;40496:22;;40517:1;;40496:22;:::i;:::-;40476:42;;40552:13;40539:9;:26;40535:405;;40586:17;40606:3;:11;;40618:9;40606:22;;;;;;;;:::i;:::-;;;;;;;;;40586:42;;40760:9;40731:3;:11;;40743:13;40731:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;40845:23;;;:12;;;:23;;;;;:36;;;40535:405;41021:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;41116:3;:12;;:19;41129:5;41116:19;;;;;;;;;;;41109:26;;;41159:4;41152:11;;;;;;;40044:1176;41203:5;41196:12;;;;;41991:120;42058:7;42085:3;:11;;42097:5;42085:18;;;;;;;;:::i;:::-;;;;;;;;;42078:25;;41991:120;;;;:::o;24278:229::-;24415:12;24447:52;24469:6;24477:4;24483:1;24486:12;24447:21;:52::i;65725:364::-;65808:57;65825:4;65840:10;65853:11;65808:8;:57::i;:::-;65880:107;;-1:-1:-1;;;65880:107:0;;65933:4;65880:107;;;18397:34:1;18447:18;;;18440:34;;;65953:1:0;18490:18:1;;;18483:34;;;18533:18;;;18526:34;;;18576:19;;;18569:44;65971:15:0;18629:19:1;;;18622:35;65880:10:0;-1:-1:-1;;;;;65880:26:0;;;;65914:9;;18331:19:1;;65880:107:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65880:107:0;;;;;;;;-1:-1:-1;;65880:107:0;;;;;;;;;;;;:::i;:::-;;;65876:206;;;-1:-1:-1;;66008:53:0;;;19181:25:1;;;19237:2;19222:18;;19215:34;;;66045:15:0;19265:18:1;;;19258:34;66008:53:0;;;;-1:-1:-1;66008:53:0;;;;19169:2:1;66008:53:0;;;65725:364;;:::o;25398:455::-;25568:12;25626:5;25601:21;:30;;25593:81;;;;-1:-1:-1;;;25593:81:0;;19505:2:1;25593:81:0;;;19487:21:1;19544:2;19524:18;;;19517:30;19583:34;19563:18;;;19556:62;-1:-1:-1;;;19634:18:1;;;19627:36;19680:19;;25593:81:0;19303:402:1;25593:81:0;25686:12;25700:23;25727:6;-1:-1:-1;;;;;25727:11:0;25746:5;25753:4;25727:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25685:73;;;;25776:69;25803:6;25811:7;25820:10;25832:12;25776:26;:69::i;:::-;25769:76;25398:455;-1:-1:-1;;;;;;;25398:455:0:o;27971:644::-;28156:12;28185:7;28181:427;;;28213:10;:17;28234:1;28213:22;28209:290;;-1:-1:-1;;;;;21816:19:0;;;28423:60;;;;-1:-1:-1;;;28423:60:0;;19912:2:1;28423:60:0;;;19894:21:1;19951:2;19931:18;;;19924:30;19990:31;19970:18;;;19963:59;20039:18;;28423:60:0;19710:353:1;28423:60:0;-1:-1:-1;28520:10:0;28513:17;;28181:427;28563:33;28571:10;28583:12;29318:17;;:21;29314:388;;29550:10;29544:17;29607:15;29594:10;29590:2;29586:19;29579:44;29314:388;29677:12;29670:20;;-1:-1:-1;;;29670:20:0;;;;;;;;:::i;196:250:1:-;281:1;291:113;305:6;302:1;299:13;291:113;;;381:11;;;375:18;362:11;;;355:39;327:2;320:10;291:113;;;-1:-1:-1;;438:1:1;420:16;;413:27;196:250::o;451:396::-;600:2;589:9;582:21;563:4;632:6;626:13;675:6;670:2;659:9;655:18;648:34;691:79;763:6;758:2;747:9;743:18;738:2;730:6;726:15;691:79;:::i;:::-;831:2;810:15;-1:-1:-1;;806:29:1;791:45;;;;838:2;787:54;;451:396;-1:-1:-1;;451:396:1:o;852:131::-;-1:-1:-1;;;;;927:31:1;;917:42;;907:70;;973:1;970;963:12;988:315;1056:6;1064;1117:2;1105:9;1096:7;1092:23;1088:32;1085:52;;;1133:1;1130;1123:12;1085:52;1172:9;1159:23;1191:31;1216:5;1191:31;:::i;:::-;1241:5;1293:2;1278:18;;;;1265:32;;-1:-1:-1;;;988:315:1:o;1500:592::-;1613:6;1621;1629;1637;1645;1653;1661;1714:3;1702:9;1693:7;1689:23;1685:33;1682:53;;;1731:1;1728;1721:12;1682:53;-1:-1:-1;;1754:23:1;;;1824:2;1809:18;;1796:32;;-1:-1:-1;1875:2:1;1860:18;;1847:32;;1926:2;1911:18;;1898:32;;-1:-1:-1;1977:3:1;1962:19;;1949:33;;-1:-1:-1;2029:3:1;2014:19;;2001:33;;-1:-1:-1;2081:3:1;2066:19;2053:33;;-1:-1:-1;1500:592:1;-1:-1:-1;1500:592:1:o;2097:813::-;2192:6;2200;2208;2216;2224;2277:3;2265:9;2256:7;2252:23;2248:33;2245:53;;;2294:1;2291;2284:12;2245:53;2333:9;2320:23;2352:31;2377:5;2352:31;:::i;:::-;2402:5;-1:-1:-1;2459:2:1;2444:18;;2431:32;2472:33;2431:32;2472:33;:::i;:::-;2524:7;-1:-1:-1;2583:2:1;2568:18;;2555:32;2596:33;2555:32;2596:33;:::i;:::-;2648:7;-1:-1:-1;2707:2:1;2692:18;;2679:32;2720:33;2679:32;2720:33;:::i;:::-;2772:7;-1:-1:-1;2831:3:1;2816:19;;2803:33;2845;2803;2845;:::i;:::-;2897:7;2887:17;;;2097:813;;;;;;;;:::o;2915:456::-;2992:6;3000;3008;3061:2;3049:9;3040:7;3036:23;3032:32;3029:52;;;3077:1;3074;3067:12;3029:52;3116:9;3103:23;3135:31;3160:5;3135:31;:::i;:::-;3185:5;-1:-1:-1;3242:2:1;3227:18;;3214:32;3255:33;3214:32;3255:33;:::i;:::-;2915:456;;3307:7;;-1:-1:-1;;;3361:2:1;3346:18;;;;3333:32;;2915:456::o;3790:247::-;3849:6;3902:2;3890:9;3881:7;3877:23;3873:32;3870:52;;;3918:1;3915;3908:12;3870:52;3957:9;3944:23;3976:31;4001:5;3976:31;:::i;4042:118::-;4128:5;4121:13;4114:21;4107:5;4104:32;4094:60;;4150:1;4147;4140:12;4165:382;4230:6;4238;4291:2;4279:9;4270:7;4266:23;4262:32;4259:52;;;4307:1;4304;4297:12;4259:52;4346:9;4333:23;4365:31;4390:5;4365:31;:::i;:::-;4415:5;-1:-1:-1;4472:2:1;4457:18;;4444:32;4485:30;4444:32;4485:30;:::i;:::-;4534:7;4524:17;;;4165:382;;;;;:::o;4981:241::-;5037:6;5090:2;5078:9;5069:7;5065:23;5061:32;5058:52;;;5106:1;5103;5096:12;5058:52;5145:9;5132:23;5164:28;5186:5;5164:28;:::i;5227:180::-;5286:6;5339:2;5327:9;5318:7;5314:23;5310:32;5307:52;;;5355:1;5352;5345:12;5307:52;-1:-1:-1;5378:23:1;;5227:180;-1:-1:-1;5227:180:1:o;5412:388::-;5480:6;5488;5541:2;5529:9;5520:7;5516:23;5512:32;5509:52;;;5557:1;5554;5547:12;5509:52;5596:9;5583:23;5615:31;5640:5;5615:31;:::i;:::-;5665:5;-1:-1:-1;5722:2:1;5707:18;;5694:32;5735:33;5694:32;5735:33;:::i;6150:380::-;6229:1;6225:12;;;;6272;;;6293:61;;6347:4;6339:6;6335:17;6325:27;;6293:61;6400:2;6392:6;6389:14;6369:18;6366:38;6363:161;;6446:10;6441:3;6437:20;6434:1;6427:31;6481:4;6478:1;6471:15;6509:4;6506:1;6499:15;6363:161;;6150:380;;;:::o;6535:127::-;6596:10;6591:3;6587:20;6584:1;6577:31;6627:4;6624:1;6617:15;6651:4;6648:1;6641:15;6667:125;6732:9;;;6753:10;;;6750:36;;;6766:18;;:::i;6797:128::-;6864:9;;;6885:11;;;6882:37;;;6899:18;;:::i;6930:184::-;7000:6;7053:2;7041:9;7032:7;7028:23;7024:32;7021:52;;;7069:1;7066;7059:12;7021:52;-1:-1:-1;7092:16:1;;6930:184;-1:-1:-1;6930:184:1:o;7398:245::-;7465:6;7518:2;7506:9;7497:7;7493:23;7489:32;7486:52;;;7534:1;7531;7524:12;7486:52;7566:9;7560:16;7585:28;7607:5;7585:28;:::i;8305:251::-;8375:6;8428:2;8416:9;8407:7;8403:23;8399:32;8396:52;;;8444:1;8441;8434:12;8396:52;8476:9;8470:16;8495:31;8520:5;8495:31;:::i;9816:287::-;9945:3;9983:6;9977:13;9999:66;10058:6;10053:3;10046:4;10038:6;10034:17;9999:66;:::i;:::-;10081:16;;;;;9816:287;-1:-1:-1;;9816:287:1:o;13343:168::-;13416:9;;;13447;;13464:15;;;13458:22;;13444:37;13434:71;;13485:18;;:::i;13516:217::-;13556:1;13582;13572:132;;13626:10;13621:3;13617:20;13614:1;13607:31;13661:4;13658:1;13651:15;13689:4;13686:1;13679:15;13572:132;-1:-1:-1;13718:9:1;;13516:217::o;13738:127::-;13799:10;13794:3;13790:20;13787:1;13780:31;13830:4;13827:1;13820:15;13854:4;13851:1;13844:15;13870:461;13923:3;13961:5;13955:12;13988:6;13983:3;13976:19;14014:4;14043:2;14038:3;14034:12;14027:19;;14080:2;14073:5;14069:14;14101:1;14111:195;14125:6;14122:1;14119:13;14111:195;;;14190:13;;-1:-1:-1;;;;;14186:39:1;14174:52;;14246:12;;;;14281:15;;;;14222:1;14140:9;14111:195;;;-1:-1:-1;14322:3:1;;13870:461;-1:-1:-1;;;;;13870:461:1:o;14336:684::-;14663:6;14652:9;14645:25;14706:6;14701:2;14690:9;14686:18;14679:34;14749:3;14744:2;14733:9;14729:18;14722:31;14626:4;14770:57;14822:3;14811:9;14807:19;14799:6;14770:57;:::i;:::-;-1:-1:-1;;;;;14901:15:1;;;14896:2;14881:18;;14874:43;14954:15;;;;14948:3;14933:19;;14926:44;14854:3;14986:19;14979:35;14762:65;14336:684;-1:-1:-1;;;;14336:684:1:o;15025:582::-;15324:6;15313:9;15306:25;15367:6;15362:2;15351:9;15347:18;15340:34;15410:3;15405:2;15394:9;15390:18;15383:31;15287:4;15431:57;15483:3;15472:9;15468:19;15460:6;15431:57;:::i;:::-;-1:-1:-1;;;;;15524:32:1;;;;15519:2;15504:18;;15497:60;-1:-1:-1;15588:3:1;15573:19;15566:35;15423:65;15025:582;-1:-1:-1;;;15025:582:1:o;17924:127::-;17985:10;17980:3;17976:20;17973:1;17966:31;18016:4;18013:1;18006:15;18040:4;18037:1;18030:15;18668:306;18756:6;18764;18772;18825:2;18813:9;18804:7;18800:23;18796:32;18793:52;;;18841:1;18838;18831:12;18793:52;18870:9;18864:16;18854:26;;18920:2;18909:9;18905:18;18899:25;18889:35;;18964:2;18953:9;18949:18;18943:25;18933:35;;18668:306;;;;;:::o

Swarm Source

ipfs://d7108740a8d712d3721df2e72900cc3a1471d5de93dd3f9c5bed3041f6fe678d

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