Token

ERC-20: Samurai Bot (Sambo)

ERC-20

Overview

Max Total Supply

1,100,000,000 Sambo

Holders

234

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xAE7e876F20436FbdE58Fb8334A4f57A69ffB011d

Filtered by Token Holder

0xec00CC73126c622A8a9896CB9617B1D6B495302b

Balance

13,999,922.3 Sambo

Value

$0.00

0xec00cc73126c622a8a9896cb9617b1d6b495302b

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Sambo

Compiler Version

v0.8.26+commit.8a97fa7a

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-09-25
*/

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


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

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

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

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


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

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

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

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;





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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

        emit Transfer(from, to, value);
    }

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

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

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

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

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


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

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

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

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

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

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// File: @uniswap/v2-periphery/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 swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

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

// File: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol

pragma solidity >=0.6.2;


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

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

// File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol

pragma solidity >=0.5.0;

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

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

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

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

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

// File: Sambo/Sambo.sol


pragma solidity 0.8.26;







/**
 * @title Sambo ERC20 Token Contract
 * @dev This contract implements an ERC20 token with customizable fees, Uniswap integration, auto liquidity, and security best practices.
 */
contract Sambo is Context, ERC20, Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    // Uniswap router and pair addresses
    IUniswapV2Router02 public uniswapV2Router;
    address public uniswapV2Pair;

    // Mappings for pairs, fee exclusions, and transaction blocks
    mapping(address => bool) public pair;
    mapping(address => bool) public _isExcludedFromFees;
    mapping(address => uint256) public lastTxBlock;

    // Token and wallet configurations
    uint256 private maxWallet;
    uint256 private _supply;
    uint256 public swapTokensAtAmount;
    uint256 public maxTxAmount;

    // Additional wallets for fee distribution
    address payable public alphaWallet;
    address payable public devWallet;
    address payable public leadWallet;
    address payable public investmentWallet;

    // Split percentages
    uint256 public alphaSplit = 20;
    uint256 public devSplit = 30;
    uint256 public leadSplit = 25;
    uint256 public investmentSplit = 25;

    // Fee configuration
    uint256 public tokenBuyTax;
    uint256 public tokenSellTax;
    uint256 public liquidityTax;
    uint256 public constant MAX_FEE = 100; // Maximum fee cap set at 10%

    // Swap state
    bool public swapping;

    // Anti-snipe configurations
    bool public tradingEnabled;
    uint256 public tradingDelay = 2; // Blocks delay post enabling trading

    // Events for transparency and logging
    event SwapRouterUpdated(address indexed newRouter);
    event TaxesSent(uint256 ethAmount);
    event SwapAmountUpdated(uint256 newAmount);
    event TokenTaxesUpdated(uint256 newTokenBuyTax, uint256 newTokenSellTax, uint256 newLiquidityTax);
    event SplitPercentagesUpdated(uint256 newAlphaSplit, uint256 newDevSplit, uint256 newLeadSplit, uint256 newInvestmentSplit);
    event PairAdded(address indexed newPair);
    event EtherWithdrawn(address[] recipients, uint256[] amounts);
    event TradingEnabled();
    event TaxWalletsUpdated(address alphaWallet, address devWallet, address leadWallet, address investmentWallet);

    /**
     * @dev Constructor to initialize the contract.
     * @param _alphaWallet The address of the alpha wallet.
     * @param _devWallet The address of the dev wallet.
     * @param _leadWallet The address of the lead wallet.
     * @param _investmentWallet The address of the investment wallet.
     */
    constructor(
        address payable _alphaWallet,
        address payable _devWallet,
        address payable _leadWallet,
        address payable _investmentWallet
    ) ERC20("Samurai Bot", "Sambo") Ownable(msg.sender) {
        uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); // Router address for Uniswap

        address _pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
        pair[_pair] = true;
        uniswapV2Pair = _pair;

        tokenBuyTax = 50; // 5% Initial Rate
        tokenSellTax = 100; // 10% 
        liquidityTax = 0; // 0%

        // Creating a total supply of 1.1 billion tokens with the appropriate decimals
        _supply = 11 * 10 ** 8 * 10 ** decimals();
        swapTokensAtAmount = _supply / 10000; // Default to 0.01% of the total supply

        maxWallet = 11 * 10 ** 8 * 10 ** decimals(); // Maximum tokens per wallet set to total supply
        maxTxAmount = 11 * 10 ** 8 * 10 ** decimals(); // Set max transaction amount to total supply

        alphaWallet = _alphaWallet;
        devWallet = _devWallet;
        leadWallet = _leadWallet;
        investmentWallet = _investmentWallet;

        _isExcludedFromFees[address(this)] = true;
        _isExcludedFromFees[owner()] = true;

        _mint(owner(), _supply);
    }

    /**
     * @dev Function to receive ether when sent directly to the contract.
     */
    receive() external payable {}

    /**
     * @dev Burns a specified amount of tokens.
     * @param amount The amount of tokens to burn.
     */
    function burn(uint256 amount) public {
        require(amount > 0, "Burn amount must be greater than zero");
        _burn(msg.sender, amount * 10 ** decimals());
    }

    /**
     * @dev Updates the minimum token amount to trigger a swap.
     * @param _amount The new swap amount.
     * Emits a {SwapAmountUpdated} event.
     */
    function updateSwapAmount(uint256 _amount) external onlyOwner {
        require(_amount > 0, "Swap amount must be greater than zero");
        swapTokensAtAmount = _amount;
        emit SwapAmountUpdated(_amount);
    }

    /**
     * @dev Updates the token buy, sell, and liquidity taxes.
     * @param _tokenBuyTax The new token buy tax.
     * @param _tokenSellTax The new token sell tax.
     * @param _liquidityTax The new liquidity tax.
     * Emits a {TokenTaxesUpdated} event.
     */
    function updateTokenTaxes(uint256 _tokenBuyTax, uint256 _tokenSellTax, uint256 _liquidityTax) external onlyOwner {
        require(_tokenBuyTax + _liquidityTax <= MAX_FEE, "Total buy tax exceeds maximum limit");
        require(_tokenSellTax + _liquidityTax <= MAX_FEE, "Total sell tax exceeds maximum limit");
        tokenBuyTax = _tokenBuyTax;
        tokenSellTax = _tokenSellTax;
        liquidityTax = _liquidityTax;
        emit TokenTaxesUpdated(_tokenBuyTax, _tokenSellTax, _liquidityTax);
    }

    /**
     * @dev Updates the split percentages for Alpha, Dev, Lead, and Investment.
     * @param _alphaSplit The new percentage for Alpha.
     * @param _devSplit The new percentage for Dev.
     * @param _leadSplit The new percentage for Lead.
     * @param _investmentSplit The new percentage for Investment.
     * Emits a {SplitPercentagesUpdated} event.
     */
    function updateSplitPercentages(uint256 _alphaSplit, uint256 _devSplit, uint256 _leadSplit, uint256 _investmentSplit) external onlyOwner {
        require(_alphaSplit + _devSplit + _leadSplit + _investmentSplit == 100, "Total split percentages must equal 100");
        alphaSplit = _alphaSplit;
        devSplit = _devSplit;
        leadSplit = _leadSplit;
        investmentSplit = _investmentSplit;
        emit SplitPercentagesUpdated(_alphaSplit, _devSplit, _leadSplit, _investmentSplit);
    }

    /**
     * @dev Enables trading by recording the block number.
     * Emits a {TradingEnabled} event.
     */
    function enableTrading() external onlyOwner {
        require(!tradingEnabled, "Trading is already enabled");
        tradingEnabled = true;
        emit TradingEnabled();
    }

    /**
     * @dev updateTaxWallets to initialize the contract.
     * @param _alphaWallet The address of the alpha wallet.
     * @param _devWallet The address of the dev wallet.
     * @param _leadWallet The address of the lead wallet.
     * @param _investmentWallet The address of the investment wallet.
     */
    function updateTaxWallets(address payable _alphaWallet, address payable _devWallet, address payable _leadWallet, address payable _investmentWallet) external onlyOwner {
        alphaWallet = _alphaWallet;
        devWallet = _devWallet;
        leadWallet = _leadWallet;
        investmentWallet = _investmentWallet;

        emit TaxWalletsUpdated(alphaWallet, devWallet, leadWallet, investmentWallet);
    }

    /**
     * @dev Internal function to handle updates of transfer, including fee deduction and anti-snipe mechanics.
     * @param from The address sending the tokens.
     * @param to The address receiving the tokens.
     * @param amount The amount of tokens being sent.
     */
    function _update(address from, address to, uint256 amount) internal override nonReentrant {
        require(tradingEnabled || _isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not yet enabled");

        // Check max transaction amount and trading delay
        if (to != address(0) && to != uniswapV2Pair && !_isExcludedFromFees[to] && !_isExcludedFromFees[from]) {
            require(block.number >= lastTxBlock[to] + tradingDelay, "Attempting to trade too frequently");
            uint256 balance = balanceOf(to);
            require(balance + amount <= maxWallet, "Transfer amount exceeds maximum wallet");
            require(amount <= maxTxAmount, "Transfer amount exceeds maximum transaction limit");
            lastTxBlock[to] = block.number;
        }

        uint256 contractTokenBalance = balanceOf(address(this));
        bool canSwap = contractTokenBalance >= swapTokensAtAmount;

        if (canSwap && !swapping && pair[to] && from != address(uniswapV2Router) && from != owner() && to != owner() && !_isExcludedFromFees[to] && !_isExcludedFromFees[from]) {
            swapping = true;

            uint256 liquidityTokens = (liquidityTax > 0) ? (contractTokenBalance * liquidityTax) / (tokenSellTax + liquidityTax) : 0;
            uint256 distributionTokens = contractTokenBalance - liquidityTokens;

            // Swap tokens for ETH for distribution
            uint256 halfLiquidityTokens = liquidityTokens / 2;
            uint256 otherHalfLiquidityTokens = liquidityTokens - halfLiquidityTokens;

            uint256 initialBalance = address(this).balance;
            uint256 tokensToSwap = distributionTokens + halfLiquidityTokens;
            swapTokensForEth(tokensToSwap);
            uint256 newBalance = address(this).balance - initialBalance;

            uint256 liquidityETH = (liquidityTax > 0) ? (newBalance * liquidityTax) / (tokenSellTax + liquidityTax) : 0;

            // Distribute the ETH to the wallets based on updated percentages
            uint256 ethBalance = newBalance - liquidityETH;

            uint256 alphaShare = (ethBalance * alphaSplit) / 100;
            uint256 devShare = (ethBalance * devSplit) / 100;
            uint256 leadShare = (ethBalance * leadSplit) / 100;
            uint256 investmentShare = (ethBalance * investmentSplit) / 100;

            (bool alphaSent, ) = alphaWallet.call{value: alphaShare}("");
            require(alphaSent, "Failed to send Alpha share");

            (bool devSent, ) = devWallet.call{value: devShare}("");
            require(devSent, "Failed to send Dev share");

            (bool leadSent, ) = leadWallet.call{value: leadShare}("");
            require(leadSent, "Failed to send Lead share");

            (bool investmentSent, ) = investmentWallet.call{value: investmentShare}("");
            require(investmentSent, "Failed to send Investment share");

            // Add liquidity to Uniswap
            if (liquidityTax > 0) {
                addLiquidity(otherHalfLiquidityTokens, liquidityETH);
            }

            emit TaxesSent(ethBalance);

            swapping = false;
        }

        bool takeFee = !swapping;

        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
            takeFee = false;
        }

        if (takeFee) {
            uint256 feeAmount = 0;

            if (pair[to]) { // Sell
                feeAmount = (amount * (tokenSellTax + liquidityTax)) / 1000;
            } else if (pair[from]) { // Buy
                feeAmount = (amount * (tokenBuyTax + liquidityTax)) / 1000;
            }

            if (feeAmount > 0) {
                amount -= feeAmount;
                super._update(from, address(this), feeAmount);
            }
        }

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

    /**
     * @dev Swaps tokens for ETH using Uniswap.
     * @param tokenAmount The amount of tokens to swap.
     */
    function swapTokensForEth(uint256 tokenAmount) private {
        require(tokenAmount > 0, "Token amount must be greater than zero");
        require(balanceOf(address(this)) >= tokenAmount, "Insufficient tokens in contract");

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

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

        // Make the swap
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // Accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }

    /**
     * @dev Adds liquidity to Uniswap.
     * @param tokenAmount The amount of tokens.
     * @param ethAmount The amount of ETH.
     */
    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        _approve(address(this), address(uniswapV2Router), tokenAmount);

        // Add the liquidity
        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0, // Slippage is unavoidable
            0, // Slippage is unavoidable
            owner(),
            block.timestamp
        );
    }

    /**
     * @dev Allows the owner to withdraw excess ETH from the contract to any of the fee distribution wallets.
     * Emits an {EtherWithdrawn} event.
     */
    function withdrawETH() external onlyOwner nonReentrant {
        require(!swapping, "Swap is in progress");
        uint256 balance = address(this).balance;
        require(balance > 0, "No ETH to withdraw");

        // Distribute remaining ETH to wallets based on split percentages
        uint256 alphaShare = (balance * alphaSplit) / 100;
        uint256 devShare = (balance * devSplit) / 100;
        uint256 leadShare = (balance * leadSplit) / 100;
        uint256 investmentShare = (balance * investmentSplit) / 100;

        address[] memory recipients = new address[](4);
        recipients[0] = alphaWallet;
        recipients[1] = devWallet;
        recipients[2] = leadWallet;
        recipients[3] = investmentWallet;

        uint256[] memory amounts = new uint256[](4);
        amounts[0] = alphaShare;
        amounts[1] = devShare;
        amounts[2] = leadShare;
        amounts[3] = investmentShare;

        (bool alphaSent, ) = alphaWallet.call{value: alphaShare}("");
        require(alphaSent, "Failed to send Alpha share");

        (bool devSent, ) = devWallet.call{value: devShare}("");
        require(devSent, "Failed to send Dev share");

        (bool leadSent, ) = leadWallet.call{value: leadShare}("");
        require(leadSent, "Failed to send Lead share");

        (bool investmentSent, ) = investmentWallet.call{value: investmentShare}("");
        require(investmentSent, "Failed to send Investment share");

        emit EtherWithdrawn(recipients, amounts);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address payable","name":"_alphaWallet","type":"address"},{"internalType":"address payable","name":"_devWallet","type":"address"},{"internalType":"address payable","name":"_leadWallet","type":"address"},{"internalType":"address payable","name":"_investmentWallet","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"recipients","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"EtherWithdrawn","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":true,"internalType":"address","name":"newPair","type":"address"}],"name":"PairAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newAlphaSplit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newDevSplit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newLeadSplit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newInvestmentSplit","type":"uint256"}],"name":"SplitPercentagesUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"SwapAmountUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newRouter","type":"address"}],"name":"SwapRouterUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"alphaWallet","type":"address"},{"indexed":false,"internalType":"address","name":"devWallet","type":"address"},{"indexed":false,"internalType":"address","name":"leadWallet","type":"address"},{"indexed":false,"internalType":"address","name":"investmentWallet","type":"address"}],"name":"TaxWalletsUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"ethAmount","type":"uint256"}],"name":"TaxesSent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newTokenBuyTax","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTokenSellTax","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newLiquidityTax","type":"uint256"}],"name":"TokenTaxesUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"TradingEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"alphaSplit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"alphaWallet","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devSplit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devWallet","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"investmentSplit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"investmentWallet","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastTxBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"leadSplit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"leadWallet","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTxAmount","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":[{"internalType":"address","name":"","type":"address"}],"name":"pair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapping","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":"tokenBuyTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenSellTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_alphaSplit","type":"uint256"},{"internalType":"uint256","name":"_devSplit","type":"uint256"},{"internalType":"uint256","name":"_leadSplit","type":"uint256"},{"internalType":"uint256","name":"_investmentSplit","type":"uint256"}],"name":"updateSplitPercentages","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"updateSwapAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_alphaWallet","type":"address"},{"internalType":"address payable","name":"_devWallet","type":"address"},{"internalType":"address payable","name":"_leadWallet","type":"address"},{"internalType":"address payable","name":"_investmentWallet","type":"address"}],"name":"updateTaxWallets","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenBuyTax","type":"uint256"},{"internalType":"uint256","name":"_tokenSellTax","type":"uint256"},{"internalType":"uint256","name":"_liquidityTax","type":"uint256"}],"name":"updateTokenTaxes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawETH","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)

0000000000000000000000002b9ab6ed51775f774c0a033fe1c447f4d4ef31a400000000000000000000000032f4c9309e2a340079760dc00585686a0a22975e00000000000000000000000054fc96b9da9fbdc4eaa4c62226041fb0037b93780000000000000000000000002fc297f638021aa912714b7afbe39923e55b030b

-----Decoded View---------------
Arg [0] : _alphaWallet (address): 0x2B9aB6ed51775F774C0A033fe1c447F4d4ef31a4
Arg [1] : _devWallet (address): 0x32f4C9309e2A340079760dc00585686a0a22975E
Arg [2] : _leadWallet (address): 0x54fC96B9DA9fbDC4eAa4C62226041fB0037B9378
Arg [3] : _investmentWallet (address): 0x2FC297f638021aA912714B7aFbe39923E55B030b

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000002b9ab6ed51775f774c0a033fe1c447f4d4ef31a4
Arg [1] : 00000000000000000000000032f4c9309e2a340079760dc00585686a0a22975e
Arg [2] : 00000000000000000000000054fc96b9da9fbdc4eaa4c62226041fb0037b9378
Arg [3] : 0000000000000000000000002fc297f638021aa912714b7afbe39923e55b030b

Deployed Bytecode Sourcemap

51294:14703:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13297:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15590:190;;;;;;;;;;-1:-1:-1;15590:190:0;;;;;:::i;:::-;;:::i;:::-;;;1110:14:1;;1103:22;1085:41;;1073:2;1058:18;15590:190:0;945:187:1;51437:41:0;;;;;;;;;;-1:-1:-1;51437:41:0;;;;-1:-1:-1;;;;;51437:41:0;;;;;;-1:-1:-1;;;;;1328:32:1;;;1310:51;;1298:2;1283:18;51437:41:0;1137:230:1;52538:20:0;;;;;;;;;;-1:-1:-1;52538:20:0;;;;;;;;14399:99;;;;;;;;;;-1:-1:-1;14478:12:0;;14399:99;;;1518:25:1;;;1506:2;1491:18;14399:99:0;1372:177:1;16358:249:0;;;;;;;;;;-1:-1:-1;16358:249:0;;;;;:::i;:::-;;:::i;14250:84::-;;;;;;;;;;-1:-1:-1;14250:84:0;;14324:2;2209:36:1;;2197:2;2182:18;14250:84:0;2067:184:1;52201:28:0;;;;;;;;;;;;;;;;55359:171;;;;;;;;;;-1:-1:-1;55359:171:0;;;;;:::i;:::-;;:::i;:::-;;51485:28;;;;;;;;;;-1:-1:-1;51485:28:0;;;;-1:-1:-1;;;;;51485:28:0;;;52601:26;;;;;;;;;;-1:-1:-1;52601:26:0;;;;;;;;;;;56219:511;;;;;;;;;;-1:-1:-1;56219:511:0;;;;;:::i;:::-;;:::i;58263:416::-;;;;;;;;;;-1:-1:-1;58263:416:0;;;;;:::i;:::-;;:::i;14561:118::-;;;;;;;;;;-1:-1:-1;14561:118:0;;;;;:::i;:::-;-1:-1:-1;;;;;14653:18:0;14626:7;14653:18;;;;;;;;;;;;14561:118;41135:103;;;;;;;;;;;;;:::i;51589:36::-;;;;;;;;;;-1:-1:-1;51589:36:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;57750:181;;;;;;;;;;;;;:::i;51887:26::-;;;;;;;;;;;;;;;;40460:87;;;;;;;;;;-1:-1:-1;40533:6:0;;-1:-1:-1;;;;;40533:6:0;40460:87;;52011:32;;;;;;;;;;-1:-1:-1;52011:32:0;;;;-1:-1:-1;;;;;52011:32:0;;;52342:26;;;;;;;;;;;;;;;;52236:29;;;;;;;;;;;;;;;;52050:33;;;;;;;;;;-1:-1:-1;52050:33:0;;;;-1:-1:-1;;;;;52050:33:0;;;13507:95;;;;;;;;;;;;;:::i;57118:506::-;;;;;;;;;;-1:-1:-1;57118:506:0;;;;;:::i;:::-;;:::i;52164:30::-;;;;;;;;;;;;;;;;14884:182;;;;;;;;;;-1:-1:-1;14884:182:0;;;;;:::i;:::-;;:::i;55708:223::-;;;;;;;;;;-1:-1:-1;55708:223:0;;;;;:::i;:::-;;:::i;52090:39::-;;;;;;;;;;-1:-1:-1;52090:39:0;;;;-1:-1:-1;;;;;52090:39:0;;;51970:34;;;;;;;;;;-1:-1:-1;51970:34:0;;;;-1:-1:-1;;;;;51970:34:0;;;52443:37;;;;;;;;;;;;52477:3;52443:37;;52409:27;;;;;;;;;;;;;;;;52375;;;;;;;;;;;;;;;;52272:35;;;;;;;;;;;;;;;;51690:46;;;;;;;;;;-1:-1:-1;51690:46:0;;;;;:::i;:::-;;;;;;;;;;;;;;15129:142;;;;;;;;;;-1:-1:-1;15129:142:0;;;;;:::i;:::-;-1:-1:-1;;;;;15236:18:0;;;15209:7;15236:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;15129:142;64457:1537;;;;;;;;;;;;;:::i;51632:51::-;;;;;;;;;;-1:-1:-1;51632:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;51847:33;;;;;;;;;;;;;;;;52634:31;;;;;;;;;;;;;;;;41393:220;;;;;;;;;;-1:-1:-1;41393:220:0;;;;;:::i;:::-;;:::i;13297:91::-;13342:13;13375:5;13368:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13297:91;:::o;15590:190::-;15663:4;4382:10;15719:31;4382:10;15735:7;15744:5;15719:8;:31::i;:::-;15768:4;15761:11;;;15590:190;;;;;:::o;16358:249::-;16445:4;4382:10;16503:37;16519:4;4382:10;16534:5;16503:15;:37::i;:::-;16551:26;16561:4;16567:2;16571:5;16551:9;:26::i;:::-;-1:-1:-1;16595:4:0;;16358:249;-1:-1:-1;;;;16358:249:0:o;55359:171::-;55424:1;55415:6;:10;55407:60;;;;-1:-1:-1;;;55407:60:0;;5922:2:1;55407:60:0;;;5904:21:1;5961:2;5941:18;;;5934:30;6000:34;5980:18;;;5973:62;-1:-1:-1;;;6051:18:1;;;6044:35;6096:19;;55407:60:0;;;;;;;;;55478:44;55484:10;55505:16;14324:2;55505;:16;:::i;:::-;55496:25;;:6;:25;:::i;:::-;55478:5;:44::i;:::-;55359:171;:::o;56219:511::-;40346:13;:11;:13::i;:::-;52477:3:::1;56351:28;56366:13:::0;56351:12;:28:::1;:::i;:::-;:39;;56343:87;;;::::0;-1:-1:-1;;;56343:87:0;;8195:2:1;56343:87:0::1;::::0;::::1;8177:21:1::0;8234:2;8214:18;;;8207:30;8273:34;8253:18;;;8246:62;-1:-1:-1;;;8324:18:1;;;8317:33;8367:19;;56343:87:0::1;7993:399:1::0;56343:87:0::1;52477:3;56449:29;56465:13:::0;56449;:29:::1;:::i;:::-;:40;;56441:89;;;::::0;-1:-1:-1;;;56441:89:0;;8599:2:1;56441:89:0::1;::::0;::::1;8581:21:1::0;8638:2;8618:18;;;8611:30;8677:34;8657:18;;;8650:62;-1:-1:-1;;;8728:18:1;;;8721:34;8772:19;;56441:89:0::1;8397:400:1::0;56441:89:0::1;56541:11;:26:::0;;;56578:12:::1;:28:::0;;;56617:12:::1;:28:::0;;;56661:61:::1;::::0;;9004:25:1;;;9060:2;9045:18;;9038:34;;;9088:18;;;9081:34;;;56661:61:0::1;::::0;8992:2:1;8977:18;56661:61:0::1;;;;;;;56219:511:::0;;;:::o;58263:416::-;40346:13;:11;:13::i;:::-;58441:11:::1;:26:::0;;-1:-1:-1;;;;;58441:26:0;;::::1;-1:-1:-1::0;;;;;;58441:26:0;;::::1;::::0;::::1;::::0;;;58478:9:::1;:22:::0;;;;::::1;::::0;;::::1;::::0;::::1;::::0;;;58511:10:::1;:24:::0;;;;::::1;::::0;;::::1;::::0;::::1;::::0;;;58546:16:::1;:36:::0;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;;58600:71:::1;::::0;;9389:51:1;;;9471:2;9456:18;;9449:60;;;;9525:18;;9518:60;;;;9609:2;9594:18;;9587:60;58600:71:0::1;::::0;9376:3:1;9361:19;58600:71:0::1;;;;;;;;58263:416:::0;;;;:::o;41135:103::-;40346:13;:11;:13::i;:::-;41200:30:::1;41227:1;41200:18;:30::i;:::-;41135:103::o:0;57750:181::-;40346:13;:11;:13::i;:::-;57814:14:::1;::::0;::::1;::::0;::::1;;;57813:15;57805:54;;;::::0;-1:-1:-1;;;57805:54:0;;9860:2:1;57805:54:0::1;::::0;::::1;9842:21:1::0;9899:2;9879:18;;;9872:30;9938:28;9918:18;;;9911:56;9984:18;;57805:54:0::1;9658:350:1::0;57805:54:0::1;57870:14;:21:::0;;-1:-1:-1;;57870:21:0::1;;;::::0;;57907:16:::1;::::0;::::1;::::0;57870:21;;57907:16:::1;57750:181::o:0;13507:95::-;13554:13;13587:7;13580:14;;;;;:::i;57118:506::-;40346:13;:11;:13::i;:::-;57313:16;57300:10;57274:23:::1;57288:9:::0;57274:11;:23:::1;:::i;:::-;:36;;;;:::i;:::-;:55;;;;:::i;:::-;57333:3;57274:62;57266:113;;;::::0;-1:-1:-1;;;57266:113:0;;10215:2:1;57266:113:0::1;::::0;::::1;10197:21:1::0;10254:2;10234:18;;;10227:30;10293:34;10273:18;;;10266:62;-1:-1:-1;;;10344:18:1;;;10337:36;10390:19;;57266:113:0::1;10013:402:1::0;57266:113:0::1;57390:10;:24:::0;;;57425:8:::1;:20:::0;;;57456:9:::1;:22:::0;;;57489:15:::1;:34:::0;;;57539:77:::1;::::0;;10651:25:1;;;10707:2;10692:18;;10685:34;;;10735:18;;;10728:34;;;10793:2;10778:18;;10771:34;;;57539:77:0::1;::::0;10638:3:1;10623:19;57539:77:0::1;10420:391:1::0;14884:182:0;14953:4;4382:10;15009:27;4382:10;15026:2;15030:5;15009:9;:27::i;55708:223::-;40346:13;:11;:13::i;:::-;55799:1:::1;55789:7;:11;55781:61;;;::::0;-1:-1:-1;;;55781:61:0;;11018:2:1;55781:61:0::1;::::0;::::1;11000:21:1::0;11057:2;11037:18;;;11030:30;11096:34;11076:18;;;11069:62;-1:-1:-1;;;11147:18:1;;;11140:35;11192:19;;55781:61:0::1;10816:401:1::0;55781:61:0::1;55853:18;:28:::0;;;55897:26:::1;::::0;1518:25:1;;;55897:26:0::1;::::0;1506:2:1;1491:18;55897:26:0::1;;;;;;;55708:223:::0;:::o;64457:1537::-;40346:13;:11;:13::i;:::-;44316:21:::1;:19;:21::i;:::-;64532:8:::2;::::0;::::2;;64531:9;64523:41;;;::::0;-1:-1:-1;;;64523:41:0;;11424:2:1;64523:41:0::2;::::0;::::2;11406:21:1::0;11463:2;11443:18;;;11436:30;-1:-1:-1;;;11482:18:1;;;11475:49;11541:18;;64523:41:0::2;11222:343:1::0;64523:41:0::2;64593:21;64633:11:::0;64625:42:::2;;;::::0;-1:-1:-1;;;64625:42:0;;11772:2:1;64625:42:0::2;::::0;::::2;11754:21:1::0;11811:2;11791:18;;;11784:30;-1:-1:-1;;;11830:18:1;;;11823:48;11888:18;;64625:42:0::2;11570:342:1::0;64625:42:0::2;64755:18;64801:3;64787:10;;64777:7;:20;;;;:::i;:::-;64776:28;;;;:::i;:::-;64755:49;;64815:16;64857:3;64845:8;;64835:7;:18;;;;:::i;:::-;64834:26;;;;:::i;:::-;64815:45;;64871:17;64915:3;64902:9;;64892:7;:19;;;;:::i;:::-;64891:27;;;;:::i;:::-;64871:47;;64929:23;64985:3;64966:15;;64956:7;:25;;;;:::i;:::-;64955:33;;;;:::i;:::-;65031:16;::::0;;65045:1:::2;65031:16:::0;;;;;::::2;::::0;;;64929:59;;-1:-1:-1;65001:27:0::2;::::0;65031:16;::::2;::::0;::::2;::::0;;::::2;::::0;::::2;-1:-1:-1::0;;65074:11:0::2;::::0;65058:13;;;;-1:-1:-1;;;;;;65074:11:0::2;::::0;65058:13;;-1:-1:-1;65074:11:0::2;::::0;65058:13:::2;;;;:::i;:::-;-1:-1:-1::0;;;;;65058:27:0;;::::2;:13;::::0;;::::2;::::0;;;;;:27;65112:9:::2;::::0;65096:13;;65112:9;::::2;::::0;65096:10;;65112:9;;65096:13;::::2;;;;;:::i;:::-;-1:-1:-1::0;;;;;65096:25:0;;::::2;:13;::::0;;::::2;::::0;;;;;:25;65148:10:::2;::::0;65132:13;;65148:10;::::2;::::0;65132;;65143:1:::2;::::0;65132:13;::::2;;;;;:::i;:::-;-1:-1:-1::0;;;;;65132:26:0;;::::2;:13;::::0;;::::2;::::0;;;;;:26;65185:16:::2;::::0;65169:13;;65185:16;::::2;::::0;65169:10;;65180:1:::2;::::0;65169:13;::::2;;;;;:::i;:::-;-1:-1:-1::0;;;;;65169:32:0;;;::::2;:13;::::0;;::::2;::::0;;;;;;:32;65241:16:::2;::::0;;65255:1:::2;65241:16:::0;;;;;::::2;::::0;;;65214:24:::2;::::0;65241:16;;65255:1;65241:16;::::2;::::0;;::::2;::::0;::::2;;::::0;-1:-1:-1;65241:16:0::2;65214:43;;65281:10;65268:7;65276:1;65268:10;;;;;;;;:::i;:::-;;;;;;:23;;;::::0;::::2;65315:8;65302:7;65310:1;65302:10;;;;;;;;:::i;:::-;;;;;;:21;;;::::0;::::2;65347:9;65334:7;65342:1;65334:10;;;;;;;;:::i;:::-;;;;;;:22;;;::::0;::::2;65380:15;65367:7;65375:1;65367:10;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;:28;65429:11:::2;::::0;:39:::2;::::0;65409:14:::2;::::0;-1:-1:-1;;;;;65429:11:0::2;::::0;65453:10;;65409:14;65429:39;65409:14;65429:39;65453:10;65429:11;:39:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65408:60;;;65487:9;65479:48;;;::::0;-1:-1:-1;;;65479:48:0;;12815:2:1;65479:48:0::2;::::0;::::2;12797:21:1::0;12854:2;12834:18;;;12827:30;12893:28;12873:18;;;12866:56;12939:18;;65479:48:0::2;12613:350:1::0;65479:48:0::2;65559:9;::::0;:35:::2;::::0;65541:12:::2;::::0;-1:-1:-1;;;;;65559:9:0::2;::::0;65581:8;;65541:12;65559:35;65541:12;65559:35;65581:8;65559:9;:35:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65540:54;;;65613:7;65605:44;;;::::0;-1:-1:-1;;;65605:44:0;;13170:2:1;65605:44:0::2;::::0;::::2;13152:21:1::0;13209:2;13189:18;;;13182:30;-1:-1:-1;;;13228:18:1;;;13221:54;13292:18;;65605:44:0::2;12968:348:1::0;65605:44:0::2;65682:10;::::0;:37:::2;::::0;65663:13:::2;::::0;-1:-1:-1;;;;;65682:10:0::2;::::0;65705:9;;65663:13;65682:37;65663:13;65682:37;65705:9;65682:10;:37:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65662:57;;;65738:8;65730:46;;;::::0;-1:-1:-1;;;65730:46:0;;13523:2:1;65730:46:0::2;::::0;::::2;13505:21:1::0;13562:2;13542:18;;;13535:30;-1:-1:-1;;;13581:18:1;;;13574:55;13646:18;;65730:46:0::2;13321:349:1::0;65730:46:0::2;65815:16;::::0;:49:::2;::::0;65790:19:::2;::::0;-1:-1:-1;;;;;65815:16:0::2;::::0;65844:15;;65790:19;65815:49;65790:19;65815:49;65844:15;65815:16;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65789:75;;;65883:14;65875:58;;;::::0;-1:-1:-1;;;65875:58:0;;13877:2:1;65875:58:0::2;::::0;::::2;13859:21:1::0;13916:2;13896:18;;;13889:30;13955:33;13935:18;;;13928:61;14006:18;;65875:58:0::2;13675:355:1::0;65875:58:0::2;65951:35;65966:10;65978:7;65951:35;;;;;;;:::i;:::-;;;;;;;;64512:1482;;;;;;;;;;;44360:20:::1;43754:1:::0;44880:7;:22;44697:213;41393:220;40346:13;:11;:13::i;:::-;-1:-1:-1;;;;;41478:22:0;::::1;41474:93;;41524:31;::::0;-1:-1:-1;;;41524:31:0;;41552:1:::1;41524:31;::::0;::::1;1310:51:1::0;1283:18;;41524:31:0::1;1137:230:1::0;41474:93:0::1;41577:28;41596:8;41577:18;:28::i;20417:130::-:0;20502:37;20511:5;20518:7;20527:5;20534:4;20502:8;:37::i;:::-;20417:130;;;:::o;22133:487::-;-1:-1:-1;;;;;15236:18:0;;;22233:24;15236:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;22300:37:0;;22296:317;;22377:5;22358:16;:24;22354:132;;;22410:60;;-1:-1:-1;;;22410:60:0;;-1:-1:-1;;;;;15494:32:1;;22410:60:0;;;15476:51:1;15543:18;;;15536:34;;;15586:18;;;15579:34;;;15449:18;;22410:60:0;15274:345:1;22354:132:0;22529:57;22538:5;22545:7;22573:5;22554:16;:24;22580:5;22529:8;:57::i;:::-;22222:398;22133:487;;;:::o;16992:308::-;-1:-1:-1;;;;;17076:18:0;;17072:88;;17118:30;;-1:-1:-1;;;17118:30:0;;17145:1;17118:30;;;1310:51:1;1283:18;;17118:30:0;1137:230:1;17072:88:0;-1:-1:-1;;;;;17174:16:0;;17170:88;;17214:32;;-1:-1:-1;;;17214:32:0;;17243:1;17214:32;;;1310:51:1;1283:18;;17214:32:0;1137:230:1;17170:88:0;17268:24;17276:4;17282:2;17286:5;17268:7;:24::i;19653:211::-;-1:-1:-1;;;;;19724:21:0;;19720:91;;19769:30;;-1:-1:-1;;;19769:30:0;;19796:1;19769:30;;;1310:51:1;1283:18;;19769:30:0;1137:230:1;19720:91:0;19821:35;19829:7;19846:1;19850:5;19821:7;:35::i;:::-;19653:211;;:::o;40625:166::-;40533:6;;-1:-1:-1;;;;;40533:6:0;4382:10;40685:23;40681:103;;40732:40;;-1:-1:-1;;;40732:40:0;;4382:10;40732:40;;;1310:51:1;1283:18;;40732:40:0;1137:230:1;41773:191:0;41866:6;;;-1:-1:-1;;;;;41883:17:0;;;-1:-1:-1;;;;;;41883:17:0;;;;;;;41916:40;;41866:6;;;41883:17;41866:6;;41916:40;;41847:16;;41916:40;41836:128;41773:191;:::o;44396:293::-;43798:1;44530:7;;:19;44522:63;;;;-1:-1:-1;;;44522:63:0;;15826:2:1;44522:63:0;;;15808:21:1;15865:2;15845:18;;;15838:30;15904:33;15884:18;;;15877:61;15955:18;;44522:63:0;15624:355:1;44522:63:0;43798:1;44663:7;:18;44396:293::o;21398:443::-;-1:-1:-1;;;;;21511:19:0;;21507:91;;21554:32;;-1:-1:-1;;;21554:32:0;;21583:1;21554:32;;;1310:51:1;1283:18;;21554:32:0;1137:230:1;21507:91:0;-1:-1:-1;;;;;21612:21:0;;21608:92;;21657:31;;-1:-1:-1;;;21657:31:0;;21685:1;21657:31;;;1310:51:1;1283:18;;21657:31:0;1137:230:1;21608:92:0;-1:-1:-1;;;;;21710:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;21756:78;;;;21807:7;-1:-1:-1;;;;;21791:31:0;21800:5;-1:-1:-1;;;;;21791:31:0;;21816:5;21791:31;;;;1518:25:1;;1506:2;1491:18;;1372:177;21791:31:0;;;;;;;;21398:443;;;;:::o;58976:3864::-;44316:21;:19;:21::i;:::-;59085:14:::1;::::0;::::1;::::0;::::1;;;::::0;:43:::1;;-1:-1:-1::0;;;;;;59103:25:0;::::1;;::::0;;;:19:::1;:25;::::0;;;;;::::1;;59085:43;:70;;;-1:-1:-1::0;;;;;;59132:23:0;::::1;;::::0;;;:19:::1;:23;::::0;;;;;::::1;;59085:70;59077:109;;;::::0;-1:-1:-1;;;59077:109:0;;16186:2:1;59077:109:0::1;::::0;::::1;16168:21:1::0;16225:2;16205:18;;;16198:30;16264:28;16244:18;;;16237:56;16310:18;;59077:109:0::1;15984:350:1::0;59077:109:0::1;-1:-1:-1::0;;;;;59262:16:0;::::1;::::0;;::::1;::::0;:39:::1;;-1:-1:-1::0;59288:13:0::1;::::0;-1:-1:-1;;;;;59282:19:0;;::::1;59288:13:::0;::::1;59282:19;;59262:39;:67;;;;-1:-1:-1::0;;;;;;59306:23:0;::::1;;::::0;;;:19:::1;:23;::::0;;;;;::::1;;59305:24;59262:67;:97;;;;-1:-1:-1::0;;;;;;59334:25:0;::::1;;::::0;;;:19:::1;:25;::::0;;;;;::::1;;59333:26;59262:97;59258:507;;;59418:12;::::0;-1:-1:-1;;;;;59400:15:0;::::1;;::::0;;;:11:::1;:15;::::0;;;;;:30:::1;::::0;59418:12;59400:30:::1;:::i;:::-;59384:12;:46;;59376:93;;;::::0;-1:-1:-1;;;59376:93:0;;16541:2:1;59376:93:0::1;::::0;::::1;16523:21:1::0;16580:2;16560:18;;;16553:30;16619:34;16599:18;;;16592:62;-1:-1:-1;;;16670:18:1;;;16663:32;16712:19;;59376:93:0::1;16339:398:1::0;59376:93:0::1;-1:-1:-1::0;;;;;14653:18:0;;59484:15:::1;14653:18:::0;;;;;;;;;;;59558:9:::1;::::0;59538:16:::1;59548:6:::0;14653:18;59538:16:::1;:::i;:::-;:29;;59530:80;;;::::0;-1:-1:-1;;;59530:80:0;;16944:2:1;59530:80:0::1;::::0;::::1;16926:21:1::0;16983:2;16963:18;;;16956:30;17022:34;17002:18;;;16995:62;-1:-1:-1;;;17073:18:1;;;17066:36;17119:19;;59530:80:0::1;16742:402:1::0;59530:80:0::1;59643:11;;59633:6;:21;;59625:83;;;::::0;-1:-1:-1;;;59625:83:0;;17351:2:1;59625:83:0::1;::::0;::::1;17333:21:1::0;17390:2;17370:18;;;17363:30;17429:34;17409:18;;;17402:62;-1:-1:-1;;;17480:18:1;;;17473:47;17537:19;;59625:83:0::1;17149:413:1::0;59625:83:0::1;-1:-1:-1::0;;;;;;59723:15:0;::::1;;::::0;;;:11:::1;:15;::::0;;;;59741:12:::1;59723:30:::0;;59258:507:::1;59826:4;59777:28;14653:18:::0;;;;;;;;;;;59882::::1;::::0;59858:42;::::1;::::0;::::1;::::0;;;59917:20:::1;;-1:-1:-1::0;59929:8:0::1;::::0;::::1;;59928:9;59917:20;:32;;;;-1:-1:-1::0;;;;;;59941:8:0;::::1;;::::0;;;:4:::1;:8;::::0;;;;;::::1;;59917:32;:68;;;;-1:-1:-1::0;59969:15:0::1;::::0;-1:-1:-1;;;;;59953:32:0;;::::1;59969:15:::0;::::1;59953:32;;59917:68;:87;;;;-1:-1:-1::0;40533:6:0;;-1:-1:-1;;;;;59989:15:0;;::::1;40533:6:::0;;59989:15:::1;;59917:87;:104;;;;-1:-1:-1::0;40533:6:0;;-1:-1:-1;;;;;60008:13:0;;::::1;40533:6:::0;;60008:13:::1;;59917:104;:132;;;;-1:-1:-1::0;;;;;;60026:23:0;::::1;;::::0;;;:19:::1;:23;::::0;;;;;::::1;;60025:24;59917:132;:162;;;;-1:-1:-1::0;;;;;;60054:25:0;::::1;;::::0;;;:19:::1;:25;::::0;;;;;::::1;;60053:26;59917:162;59913:2247;;;60096:8;:15:::0;;-1:-1:-1;;60096:15:0::1;60107:4;60096:15;::::0;;60155:12:::1;::::0;60096:8:::1;::::0;60154:94:::1;;60247:1;60154:94;;;60231:12;;60216;;:27;;;;:::i;:::-;60199:12;::::0;60176:35:::1;::::0;:20;:35:::1;:::i;:::-;60175:69;;;;:::i;:::-;60128:120:::0;-1:-1:-1;60263:26:0::1;60292:38;60128:120:::0;60292:20;:38:::1;:::i;:::-;60263:67:::0;-1:-1:-1;60400:27:0::1;60430:19;60448:1;60430:15:::0;:19:::1;:::i;:::-;60400:49:::0;-1:-1:-1;60464:32:0::1;60499:37;60400:49:::0;60499:15;:37:::1;:::i;:::-;60464:72:::0;-1:-1:-1;60578:21:0::1;60553:22;60637:40;60658:19:::0;60637:18;:40:::1;:::i;:::-;60614:63;;60692:30;60709:12;60692:16;:30::i;:::-;60737:18;60758:38;60782:14:::0;60758:21:::1;:38;:::i;:::-;60737:59;;60813:20;60852:1:::0;60837:12:::1;;:16;60836:84;;60919:1;60836:84;;;60903:12;;60888;;:27;;;;:::i;:::-;60871:12;::::0;60858:25:::1;::::0;:10;:25:::1;:::i;:::-;60857:59;;;;:::i;:::-;60813:107:::0;-1:-1:-1;61016:18:0::1;61037:25;60813:107:::0;61037:10;:25:::1;:::i;:::-;61016:46;;61079:18;61128:3;61114:10;;61101;:23;;;;:::i;:::-;61100:31;;;;:::i;:::-;61079:52;;61146:16;61191:3;61179:8;;61166:10;:21;;;;:::i;:::-;61165:29;;;;:::i;:::-;61146:48;;61209:17;61256:3;61243:9;;61230:10;:22;;;;:::i;:::-;61229:30;;;;:::i;:::-;61209:50;;61274:23;61333:3;61314:15;;61301:10;:28;;;;:::i;:::-;61300:36;;;;:::i;:::-;61374:11;::::0;:39:::1;::::0;61274:62;;-1:-1:-1;61354:14:0::1;::::0;-1:-1:-1;;;;;61374:11:0;;::::1;::::0;61398:10;;61354:14;61374:39;61354:14;61374:39;61398:10;61374:11;:39:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61353:60;;;61436:9;61428:48;;;::::0;-1:-1:-1;;;61428:48:0;;12815:2:1;61428:48:0::1;::::0;::::1;12797:21:1::0;12854:2;12834:18;;;12827:30;12893:28;12873:18;;;12866:56;12939:18;;61428:48:0::1;12613:350:1::0;61428:48:0::1;61512:9;::::0;:35:::1;::::0;61494:12:::1;::::0;-1:-1:-1;;;;;61512:9:0::1;::::0;61534:8;;61494:12;61512:35;61494:12;61512:35;61534:8;61512:9;:35:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61493:54;;;61570:7;61562:44;;;::::0;-1:-1:-1;;;61562:44:0;;13170:2:1;61562:44:0::1;::::0;::::1;13152:21:1::0;13209:2;13189:18;;;13182:30;-1:-1:-1;;;13228:18:1;;;13221:54;13292:18;;61562:44:0::1;12968:348:1::0;61562:44:0::1;61643:10;::::0;:37:::1;::::0;61624:13:::1;::::0;-1:-1:-1;;;;;61643:10:0::1;::::0;61666:9;;61624:13;61643:37;61624:13;61643:37;61666:9;61643:10;:37:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61623:57;;;61703:8;61695:46;;;::::0;-1:-1:-1;;;61695:46:0;;13523:2:1;61695:46:0::1;::::0;::::1;13505:21:1::0;13562:2;13542:18;;;13535:30;-1:-1:-1;;;13581:18:1;;;13574:55;13646:18;;61695:46:0::1;13321:349:1::0;61695:46:0::1;61784:16;::::0;:49:::1;::::0;61759:19:::1;::::0;-1:-1:-1;;;;;61784:16:0::1;::::0;61813:15;;61759:19;61784:49;61759:19;61784:49;61813:15;61784:16;:49:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61758:75;;;61856:14;61848:58;;;::::0;-1:-1:-1;;;61848:58:0;;13877:2:1;61848:58:0::1;::::0;::::1;13859:21:1::0;13916:2;13896:18;;;13889:30;13955:33;13935:18;;;13928:61;14006:18;;61848:58:0::1;13675:355:1::0;61848:58:0::1;61968:12;::::0;:16;61964:109:::1;;62005:52;62018:24;62044:12;62005;:52::i;:::-;62094:21;::::0;1518:25:1;;;62094:21:0::1;::::0;1506:2:1;1491:18;62094:21:0::1;;;;;;;-1:-1:-1::0;;62132:8:0::1;:16:::0;;-1:-1:-1;;62132:16:0::1;::::0;;-1:-1:-1;;;;;;;;;;;;;;;59913:2247:0::1;62188:8;::::0;-1:-1:-1;;;;;62213:25:0;::::1;62172:12;62213:25:::0;;;:19:::1;:25;::::0;;;;;62188:8:::1;::::0;;::::1;62187:9;::::0;62213:25:::1;::::0;:52:::1;;-1:-1:-1::0;;;;;;62242:23:0;::::1;;::::0;;;:19:::1;:23;::::0;;;;;::::1;;62213:52;62209:100;;;-1:-1:-1::0;62292:5:0::1;62209:100;62325:7;62321:468;;;-1:-1:-1::0;;;;;62391:8:0;::::1;62349:17;62391:8:::0;;;:4:::1;:8;::::0;;;;;::::1;;62387:238;;;62483:4;62466:12;;62451;;:27;;;;:::i;:::-;62441:38;::::0;:6;:38:::1;:::i;:::-;62440:47;;;;:::i;:::-;62428:59;;62387:238;;;-1:-1:-1::0;;;;;62513:10:0;::::1;;::::0;;;:4:::1;:10;::::0;;;;;::::1;;62509:116;;;62605:4;62588:12;;62574:11;;:26;;;;:::i;:::-;62564:37;::::0;:6;:37:::1;:::i;:::-;62563:46;;;;:::i;:::-;62551:58;;62509:116;62645:13:::0;;62641:137:::1;;62679:19;62689:9:::0;62679:19;::::1;:::i;:::-;;;62717:45;62731:4;62745;62752:9;62717:13;:45::i;:::-;62334:455;62321:468;62801:31;62815:4;62821:2;62825:6;62801:13;:31::i;:::-;59066:3774;;;44360:20:::0;43754:1;44880:7;:22;44697:213;62972:702;63060:1;63046:11;:15;63038:66;;;;-1:-1:-1;;;63038:66:0;;17902:2:1;63038:66:0;;;17884:21:1;17941:2;17921:18;;;17914:30;17980:34;17960:18;;;17953:62;-1:-1:-1;;;18031:18:1;;;18024:36;18077:19;;63038:66:0;17700:402:1;63038:66:0;63141:4;14626:7;14653:18;;;;;;;;;;;63151:11;-1:-1:-1;63123:39:0;63115:83;;;;-1:-1:-1;;;63115:83:0;;18309:2:1;63115:83:0;;;18291:21:1;18348:2;18328:18;;;18321:30;18387:33;18367:18;;;18360:61;18438:18;;63115:83:0;18107:355:1;63115:83:0;63235:16;;;63249:1;63235:16;;;;;;;;63211:21;;63235:16;;;;;;;;;;-1:-1:-1;63235:16:0;63211:40;;63280:4;63262;63267:1;63262:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;63262:23:0;;;:7;;;;;;;;;;:23;;;;63306:15;;:22;;;-1:-1:-1;;;63306:22:0;;;;:15;;;;;:20;;:22;;;;;63262:7;;63306:22;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63296:4;63301:1;63296:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;63296:32:0;;;:7;;;;;;;;;:32;63373:15;;63341:62;;63358:4;;63373:15;63391:11;63341:8;:62::i;:::-;63442:15;;:224;;-1:-1:-1;;;63442:224:0;;-1:-1:-1;;;;;63442:15:0;;;;:66;;:224;;63523:11;;63442:15;;63593:4;;63620;;63640:15;;63442:224;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63027:647;62972:702;:::o;63833:446::-;63946:15;;63914:62;;63931:4;;-1:-1:-1;;;;;63946:15:0;63964:11;63914:8;:62::i;:::-;64019:15;;-1:-1:-1;;;;;64019:15:0;:31;64058:9;64091:4;64111:11;64019:15;;64223:7;40533:6;;-1:-1:-1;;;;;40533:6:0;;40460:87;64223:7;64019:252;;;;;;-1:-1:-1;;;;;;64019:252:0;;;-1:-1:-1;;;;;19631:32:1;;;64019:252:0;;;19613:51:1;19680:18;;;19673:34;;;;19723:18;;;19716:34;;;;19766:18;;;19759:34;19830:32;;;19809:19;;;19802:61;64245:15:0;19879:19:1;;;19872:35;19585:19;;64019:252:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;63833:446;;:::o;17624:1135::-;-1:-1:-1;;;;;17714:18:0;;17710:552;;17868:5;17852:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;17710:552:0;;-1:-1:-1;17710:552:0;;-1:-1:-1;;;;;17928:15:0;;17906:19;17928:15;;;;;;;;;;;17962:19;;;17958:117;;;18009:50;;-1:-1:-1;;;18009:50:0;;-1:-1:-1;;;;;15494:32:1;;18009:50:0;;;15476:51:1;15543:18;;;15536:34;;;15586:18;;;15579:34;;;15449:18;;18009:50:0;15274:345:1;17958:117:0;-1:-1:-1;;;;;18198:15:0;;:9;:15;;;;;;;;;;18216:19;;;;18198:37;;17710:552;-1:-1:-1;;;;;18278:16:0;;18274:435;;18444:12;:21;;;;;;;18274:435;;;-1:-1:-1;;;;;18660:13:0;;:9;:13;;;;;;;;;;:22;;;;;;18274:435;18741:2;-1:-1:-1;;;;;18726:25:0;18735:4;-1:-1:-1;;;;;18726:25:0;;18745:5;18726:25;;;;1518::1;;1506:2;1491:18;;1372:177;18726:25:0;;;;;;;;17624:1135;;;:::o;14:418:1:-;163:2;152:9;145:21;126:4;195:6;189:13;238:6;233:2;222:9;218:18;211:34;297:6;292:2;284:6;280:15;275:2;264:9;260:18;254:50;353:1;348:2;339:6;328:9;324:22;320:31;313:42;423:2;416;412:7;407:2;399:6;395:15;391:29;380:9;376:45;372:54;364:62;;;14:418;;;;:::o;437:131::-;-1:-1:-1;;;;;512:31:1;;502:42;;492:70;;558:1;555;548:12;573:367;641:6;649;702:2;690:9;681:7;677:23;673:32;670:52;;;718:1;715;708:12;670:52;757:9;744:23;776:31;801:5;776:31;:::i;:::-;826:5;904:2;889:18;;;;876:32;;-1:-1:-1;;;573:367:1:o;1554:508::-;1631:6;1639;1647;1700:2;1688:9;1679:7;1675:23;1671:32;1668:52;;;1716:1;1713;1706:12;1668:52;1755:9;1742:23;1774:31;1799:5;1774:31;:::i;:::-;1824:5;-1:-1:-1;1881:2:1;1866:18;;1853:32;1894:33;1853:32;1894:33;:::i;:::-;1554:508;;1946:7;;-1:-1:-1;;;2026:2:1;2011:18;;;;1998:32;;1554:508::o;2256:226::-;2315:6;2368:2;2356:9;2347:7;2343:23;2339:32;2336:52;;;2384:1;2381;2374:12;2336:52;-1:-1:-1;2429:23:1;;2256:226;-1:-1:-1;2256:226:1:o;2695:466::-;2772:6;2780;2788;2841:2;2829:9;2820:7;2816:23;2812:32;2809:52;;;2857:1;2854;2847:12;2809:52;-1:-1:-1;;2902:23:1;;;3022:2;3007:18;;2994:32;;-1:-1:-1;3125:2:1;3110:18;;;3097:32;;2695:466;-1:-1:-1;2695:466:1:o;3166:703::-;3284:6;3292;3300;3308;3361:3;3349:9;3340:7;3336:23;3332:33;3329:53;;;3378:1;3375;3368:12;3329:53;3417:9;3404:23;3436:31;3461:5;3436:31;:::i;:::-;3486:5;-1:-1:-1;3543:2:1;3528:18;;3515:32;3556:33;3515:32;3556:33;:::i;:::-;3608:7;-1:-1:-1;3667:2:1;3652:18;;3639:32;3680:33;3639:32;3680:33;:::i;:::-;3732:7;-1:-1:-1;3791:2:1;3776:18;;3763:32;3804:33;3763:32;3804:33;:::i;:::-;3166:703;;;;-1:-1:-1;3166:703:1;;-1:-1:-1;;3166:703:1:o;3874:247::-;3933:6;3986:2;3974:9;3965:7;3961:23;3957:32;3954:52;;;4002:1;3999;3992:12;3954:52;4041:9;4028:23;4060:31;4085:5;4060:31;:::i;:::-;4110:5;3874:247;-1:-1:-1;;;3874:247:1:o;4350:587::-;4436:6;4444;4452;4460;4513:3;4501:9;4492:7;4488:23;4484:33;4481:53;;;4530:1;4527;4520:12;4481:53;-1:-1:-1;;4575:23:1;;;4695:2;4680:18;;4667:32;;-1:-1:-1;4798:2:1;4783:18;;4770:32;;4901:2;4886:18;4873:32;;-1:-1:-1;4350:587:1;-1:-1:-1;4350:587:1:o;4942:388::-;5010:6;5018;5071:2;5059:9;5050:7;5046:23;5042:32;5039:52;;;5087:1;5084;5077:12;5039:52;5126:9;5113:23;5145:31;5170:5;5145:31;:::i;:::-;5195:5;-1:-1:-1;5252:2:1;5237:18;;5224:32;5265:33;5224:32;5265:33;:::i;:::-;5317:7;5307:17;;;4942:388;;;;;:::o;5335:380::-;5414:1;5410:12;;;;5457;;;5478:61;;5532:4;5524:6;5520:17;5510:27;;5478:61;5585:2;5577:6;5574:14;5554:18;5551:38;5548:161;;5631:10;5626:3;5622:20;5619:1;5612:31;5666:4;5663:1;5656:15;5694:4;5691:1;5684:15;5548:161;;5335:380;;;:::o;6126:127::-;6187:10;6182:3;6178:20;6175:1;6168:31;6218:4;6215:1;6208:15;6242:4;6239:1;6232:15;6258:375;6346:1;6364:5;6378:249;6399:1;6389:8;6386:15;6378:249;;;6449:4;6444:3;6440:14;6434:4;6431:24;6428:50;;;6458:18;;:::i;:::-;6508:1;6498:8;6494:16;6491:49;;;6522:16;;;;6491:49;6605:1;6601:16;;;;;6561:15;;6378:249;;;6258:375;;;;;;:::o;6638:902::-;6687:5;6717:8;6707:80;;-1:-1:-1;6758:1:1;6772:5;;6707:80;6806:4;6796:76;;-1:-1:-1;6843:1:1;6857:5;;6796:76;6888:4;6906:1;6901:59;;;;6974:1;6969:174;;;;6881:262;;6901:59;6931:1;6922:10;;6945:5;;;6969:174;7006:3;6996:8;6993:17;6990:43;;;7013:18;;:::i;:::-;-1:-1:-1;;7069:1:1;7055:16;;7128:5;;6881:262;;7227:2;7217:8;7214:16;7208:3;7202:4;7199:13;7195:36;7189:2;7179:8;7176:16;7171:2;7165:4;7162:12;7158:35;7155:77;7152:203;;;-1:-1:-1;7264:19:1;;;7340:5;;7152:203;7387:42;-1:-1:-1;;7412:8:1;7406:4;7387:42;:::i;:::-;7465:6;7461:1;7457:6;7453:19;7444:7;7441:32;7438:58;;;7476:18;;:::i;:::-;7514:20;;6638:902;-1:-1:-1;;;6638:902:1:o;7545:140::-;7603:5;7632:47;7673:4;7663:8;7659:19;7653:4;7632:47;:::i;7690:168::-;7763:9;;;7794;;7811:15;;;7805:22;;7791:37;7781:71;;7832:18;;:::i;7863:125::-;7928:9;;;7949:10;;;7946:36;;;7962:18;;:::i;11917:217::-;11957:1;11983;11973:132;;12027:10;12022:3;12018:20;12015:1;12008:31;12062:4;12059:1;12052:15;12090:4;12087:1;12080:15;11973:132;-1:-1:-1;12119:9:1;;11917:217::o;12271:127::-;12332:10;12327:3;12323:20;12320:1;12313:31;12363:4;12360:1;12353:15;12387:4;12384:1;12377:15;14035:446;14088:3;14126:5;14120:12;14153:6;14148:3;14141:19;14185:4;14180:3;14176:14;14169:21;;14224:4;14217:5;14213:16;14247:1;14257:199;14271:6;14268:1;14265:13;14257:199;;;14336:13;;-1:-1:-1;;;;;14332:39:1;14320:52;;14401:4;14392:14;;;;14429:17;;;;14368:1;14286:9;14257:199;;;-1:-1:-1;14472:3:1;;14035:446;-1:-1:-1;;;;14035:446:1:o;14486:783::-;14743:2;14732:9;14725:21;14706:4;14769:56;14821:2;14810:9;14806:18;14798:6;14769:56;:::i;:::-;14873:9;14865:6;14861:22;14856:2;14845:9;14841:18;14834:50;14904:6;14939;14933:13;14970:6;14962;14955:22;15005:2;14997:6;14993:15;14986:22;;15043:2;15035:6;15031:15;15017:29;;15064:1;15074:169;15088:6;15085:1;15082:13;15074:169;;;15149:13;;15137:26;;15192:2;15218:15;;;;15183:12;;;;15110:1;15103:9;15074:169;;;-1:-1:-1;15260:3:1;;14486:783;-1:-1:-1;;;;;;14486:783:1:o;17567:128::-;17634:9;;;17655:11;;;17652:37;;;17669:18;;:::i;18467:251::-;18537:6;18590:2;18578:9;18569:7;18565:23;18561:32;18558:52;;;18606:1;18603;18596:12;18558:52;18638:9;18632:16;18657:31;18682:5;18657:31;:::i;18723:582::-;19022:6;19011:9;19004:25;19065:6;19060:2;19049:9;19045:18;19038:34;19108:3;19103:2;19092:9;19088:18;19081:31;18985:4;19129:57;19181:3;19170:9;19166:19;19158:6;19129:57;:::i;:::-;-1:-1:-1;;;;;19222:32:1;;;;19217:2;19202:18;;19195:60;-1:-1:-1;19286:3:1;19271:19;19264:35;19121:65;18723:582;-1:-1:-1;;;18723:582:1:o;19918:456::-;20006:6;20014;20022;20075:2;20063:9;20054:7;20050:23;20046:32;20043:52;;;20091:1;20088;20081:12;20043:52;-1:-1:-1;;20136:16:1;;20242:2;20227:18;;20221:25;20338:2;20323:18;;;20317:25;20136:16;;20221:25;;-1:-1:-1;20317:25:1;19918:456;-1:-1:-1;19918:456:1:o

Swarm Source

ipfs://46ea5f11998a2105e0dfc0380deaf79ed37d6c69d45b83cd697bd7a7fd308479

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