Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-10-01
*/

// 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: Sambo/ReentrancyGuard.sol


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

pragma solidity ^0.8.20;

/**
 * @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;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    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(bool swapping) {
        _nonReentrantBefore(swapping);
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore(bool swapping) private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED && !swapping) {
            revert ReentrancyGuardReentrantCall();
        }

        // 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;
        _isExcludedFromFees[address(0x49a18944C02e88be2be5b9bd6D754D52c5F31Df9)] = 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(swapping) {
        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 {
        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);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","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"}]

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

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

51434:14790: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;51577:41:0;;;;;;;;;;-1:-1:-1;51577:41:0;;;;-1:-1:-1;;;;;51577:41:0;;;;;;-1:-1:-1;;;;;1328:32:1;;;1310:51;;1298:2;1283:18;51577:41:0;1137:230:1;52678:20:0;;;;;;;;;;-1:-1:-1;52678: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;52341:28:0;;;;;;;;;;;;;;;;55589:171;;;;;;;;;;-1:-1:-1;55589:171:0;;;;;:::i;:::-;;:::i;:::-;;51625:28;;;;;;;;;;-1:-1:-1;51625:28:0;;;;-1:-1:-1;;;;;51625:28:0;;;52741:26;;;;;;;;;;-1:-1:-1;52741:26:0;;;;;;;;;;;56449:511;;;;;;;;;;-1:-1:-1;56449:511:0;;;;;:::i;:::-;;:::i;58493:416::-;;;;;;;;;;-1:-1:-1;58493: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;51729:36::-;;;;;;;;;;-1:-1:-1;51729:36:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;57980:181;;;;;;;;;;;;;:::i;52027:26::-;;;;;;;;;;;;;;;;40460:87;;;;;;;;;;-1:-1:-1;40533:6:0;;-1:-1:-1;;;;;40533:6:0;40460:87;;52151:32;;;;;;;;;;-1:-1:-1;52151:32:0;;;;-1:-1:-1;;;;;52151:32:0;;;52482:26;;;;;;;;;;;;;;;;52376:29;;;;;;;;;;;;;;;;52190:33;;;;;;;;;;-1:-1:-1;52190:33:0;;;;-1:-1:-1;;;;;52190:33:0;;;13507:95;;;;;;;;;;;;;:::i;57348:506::-;;;;;;;;;;-1:-1:-1;57348:506:0;;;;;:::i;:::-;;:::i;52304:30::-;;;;;;;;;;;;;;;;14884:182;;;;;;;;;;-1:-1:-1;14884:182:0;;;;;:::i;:::-;;:::i;55938:223::-;;;;;;;;;;-1:-1:-1;55938:223:0;;;;;:::i;:::-;;:::i;52230:39::-;;;;;;;;;;-1:-1:-1;52230:39:0;;;;-1:-1:-1;;;;;52230:39:0;;;52110:34;;;;;;;;;;-1:-1:-1;52110:34:0;;;;-1:-1:-1;;;;;52110:34:0;;;52583:37;;;;;;;;;;;;52617:3;52583:37;;52549:27;;;;;;;;;;;;;;;;52515;;;;;;;;;;;;;;;;52412:35;;;;;;;;;;;;;;;;51830:46;;;;;;;;;;-1:-1:-1;51830: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;64697:1524;;;;;;;;;;;;;:::i;51772:51::-;;;;;;;;;;-1:-1:-1;51772:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;51987:33;;;;;;;;;;;;;;;;52774: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;55589:171::-;55654:1;55645:6;:10;55637:60;;;;-1:-1:-1;;;55637:60:0;;5922:2:1;55637: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;;55637:60:0;;;;;;;;;55708:44;55714:10;55735:16;14324:2;55735;:16;:::i;:::-;55726:25;;:6;:25;:::i;:::-;55708:5;:44::i;:::-;55589:171;:::o;56449:511::-;40346:13;:11;:13::i;:::-;52617:3:::1;56581:28;56596:13:::0;56581:12;:28:::1;:::i;:::-;:39;;56573:87;;;::::0;-1:-1:-1;;;56573:87:0;;8195:2:1;56573: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;;56573:87:0::1;7993:399:1::0;56573:87:0::1;52617:3;56679:29;56695:13:::0;56679;:29:::1;:::i;:::-;:40;;56671:89;;;::::0;-1:-1:-1;;;56671:89:0;;8599:2:1;56671: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;;56671:89:0::1;8397:400:1::0;56671:89:0::1;56771:11;:26:::0;;;56808:12:::1;:28:::0;;;56847:12:::1;:28:::0;;;56891:61:::1;::::0;;9004:25:1;;;9060:2;9045:18;;9038:34;;;9088:18;;;9081:34;;;56891:61:0::1;::::0;8992:2:1;8977:18;56891:61:0::1;;;;;;;56449:511:::0;;;:::o;58493:416::-;40346:13;:11;:13::i;:::-;58671:11:::1;:26:::0;;-1:-1:-1;;;;;58671:26:0;;::::1;-1:-1:-1::0;;;;;;58671:26:0;;::::1;::::0;::::1;::::0;;;58708:9:::1;:22:::0;;;;::::1;::::0;;::::1;::::0;::::1;::::0;;;58741:10:::1;:24:::0;;;;::::1;::::0;;::::1;::::0;::::1;::::0;;;58776:16:::1;:36:::0;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;;58830:71:::1;::::0;;9389:51:1;;;9471:2;9456:18;;9449:60;;;;9525:18;;9518:60;;;;9609:2;9594:18;;9587:60;58830:71:0::1;::::0;9376:3:1;9361:19;58830:71:0::1;;;;;;;;58493:416:::0;;;;:::o;41135:103::-;40346:13;:11;:13::i;:::-;41200:30:::1;41227:1;41200:18;:30::i;:::-;41135:103::o:0;57980:181::-;40346:13;:11;:13::i;:::-;58044:14:::1;::::0;::::1;::::0;::::1;;;58043:15;58035:54;;;::::0;-1:-1:-1;;;58035:54:0;;9860:2:1;58035:54:0::1;::::0;::::1;9842:21:1::0;9899:2;9879:18;;;9872:30;9938:28;9918:18;;;9911:56;9984:18;;58035:54:0::1;9658:350:1::0;58035:54:0::1;58100:14;:21:::0;;-1:-1:-1;;58100:21:0::1;;;::::0;;58137:16:::1;::::0;::::1;::::0;58100:21;;58137:16:::1;57980:181::o:0;13507:95::-;13554:13;13587:7;13580:14;;;;;:::i;57348:506::-;40346:13;:11;:13::i;:::-;57543:16;57530:10;57504:23:::1;57518:9:::0;57504:11;:23:::1;:::i;:::-;:36;;;;:::i;:::-;:55;;;;:::i;:::-;57563:3;57504:62;57496:113;;;::::0;-1:-1:-1;;;57496:113:0;;10215:2:1;57496: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;;57496:113:0::1;10013:402:1::0;57496:113:0::1;57620:10;:24:::0;;;57655:8:::1;:20:::0;;;57686:9:::1;:22:::0;;;57719:15:::1;:34:::0;;;57769:77:::1;::::0;;10651:25:1;;;10707:2;10692:18;;10685:34;;;10735:18;;;10728:34;;;10793:2;10778:18;;10771:34;;;57769:77:0::1;::::0;10638:3:1;10623:19;57769: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;55938:223::-;40346:13;:11;:13::i;:::-;56029:1:::1;56019:7;:11;56011:61;;;::::0;-1:-1:-1;;;56011:61:0;;11018:2:1;56011: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;;56011:61:0::1;10816:401:1::0;56011:61:0::1;56083:18;:28:::0;;;56127:26:::1;::::0;1518:25:1;;;56127:26:0::1;::::0;1506:2:1;1491:18;56127:26:0::1;;;;;;;55938:223:::0;:::o;64697:1524::-;40346:13;:11;:13::i;:::-;64759:8:::1;::::0;::::1;;64758:9;64750:41;;;::::0;-1:-1:-1;;;64750:41:0;;11424:2:1;64750:41:0::1;::::0;::::1;11406:21:1::0;11463:2;11443:18;;;11436:30;-1:-1:-1;;;11482:18:1;;;11475:49;11541:18;;64750:41:0::1;11222:343:1::0;64750:41:0::1;64820:21;64860:11:::0;64852:42:::1;;;::::0;-1:-1:-1;;;64852:42:0;;11772:2:1;64852:42:0::1;::::0;::::1;11754:21:1::0;11811:2;11791:18;;;11784:30;-1:-1:-1;;;11830:18:1;;;11823:48;11888:18;;64852:42:0::1;11570:342:1::0;64852:42:0::1;64982:18;65028:3;65014:10;;65004:7;:20;;;;:::i;:::-;65003:28;;;;:::i;:::-;64982:49;;65042:16;65084:3;65072:8;;65062:7;:18;;;;:::i;:::-;65061:26;;;;:::i;:::-;65042:45;;65098:17;65142:3;65129:9;;65119:7;:19;;;;:::i;:::-;65118:27;;;;:::i;:::-;65098:47;;65156:23;65212:3;65193:15;;65183:7;:25;;;;:::i;:::-;65182:33;;;;:::i;:::-;65258:16;::::0;;65272:1:::1;65258:16:::0;;;;;::::1;::::0;;;65156:59;;-1:-1:-1;65228:27:0::1;::::0;65258:16;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;-1:-1:-1::0;;65301:11:0::1;::::0;65285:13;;;;-1:-1:-1;;;;;;65301:11:0::1;::::0;65285:13;;-1:-1:-1;65301:11:0::1;::::0;65285:13:::1;;;;:::i;:::-;-1:-1:-1::0;;;;;65285:27:0;;::::1;:13;::::0;;::::1;::::0;;;;;:27;65339:9:::1;::::0;65323:13;;65339:9;::::1;::::0;65323:10;;65339:9;;65323:13;::::1;;;;;:::i;:::-;-1:-1:-1::0;;;;;65323:25:0;;::::1;:13;::::0;;::::1;::::0;;;;;:25;65375:10:::1;::::0;65359:13;;65375:10;::::1;::::0;65359;;65370:1:::1;::::0;65359:13;::::1;;;;;:::i;:::-;-1:-1:-1::0;;;;;65359:26:0;;::::1;:13;::::0;;::::1;::::0;;;;;:26;65412:16:::1;::::0;65396:13;;65412:16;::::1;::::0;65396:10;;65407:1:::1;::::0;65396:13;::::1;;;;;:::i;:::-;-1:-1:-1::0;;;;;65396:32:0;;;::::1;:13;::::0;;::::1;::::0;;;;;;:32;65468:16:::1;::::0;;65482:1:::1;65468:16:::0;;;;;::::1;::::0;;;65441:24:::1;::::0;65468:16;;65482:1;65468:16;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;65468:16:0::1;65441:43;;65508:10;65495:7;65503:1;65495:10;;;;;;;;:::i;:::-;;;;;;:23;;;::::0;::::1;65542:8;65529:7;65537:1;65529:10;;;;;;;;:::i;:::-;;;;;;:21;;;::::0;::::1;65574:9;65561:7;65569:1;65561:10;;;;;;;;:::i;:::-;;;;;;:22;;;::::0;::::1;65607:15;65594:7;65602:1;65594:10;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;:28;65656:11:::1;::::0;:39:::1;::::0;65636:14:::1;::::0;-1:-1:-1;;;;;65656:11:0::1;::::0;65680:10;;65636:14;65656:39;65636:14;65656:39;65680:10;65656:11;:39:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65635:60;;;65714:9;65706:48;;;::::0;-1:-1:-1;;;65706:48:0;;12815:2:1;65706:48:0::1;::::0;::::1;12797:21:1::0;12854:2;12834:18;;;12827:30;12893:28;12873:18;;;12866:56;12939:18;;65706:48:0::1;12613:350:1::0;65706:48:0::1;65786:9;::::0;:35:::1;::::0;65768:12:::1;::::0;-1:-1:-1;;;;;65786:9:0::1;::::0;65808:8;;65768:12;65786:35;65768:12;65786:35;65808:8;65786:9;:35:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65767:54;;;65840:7;65832:44;;;::::0;-1:-1:-1;;;65832:44:0;;13170:2:1;65832: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;;65832:44:0::1;12968:348:1::0;65832:44:0::1;65909:10;::::0;:37:::1;::::0;65890:13:::1;::::0;-1:-1:-1;;;;;65909:10:0::1;::::0;65932:9;;65890:13;65909:37;65890:13;65909:37;65932:9;65909:10;:37:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65889:57;;;65965:8;65957:46;;;::::0;-1:-1:-1;;;65957:46:0;;13523:2:1;65957: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;;65957:46:0::1;13321:349:1::0;65957:46:0::1;66042:16;::::0;:49:::1;::::0;66017:19:::1;::::0;-1:-1:-1;;;;;66042:16:0::1;::::0;66071:15;;66017:19;66042:49;66017:19;66042:49;66071:15;66042:16;:49:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66016:75;;;66110:14;66102:58;;;::::0;-1:-1:-1;;;66102:58:0;;13877:2:1;66102:58:0::1;::::0;::::1;13859:21:1::0;13916:2;13896:18;;;13889:30;13955:33;13935:18;;;13928:61;14006:18;;66102:58:0::1;13675:355:1::0;66102:58:0::1;66178:35;66193:10;66205:7;66178:35;;;;;;;:::i;:::-;;;;;;;;64739:1482;;;;;;;;;;;64697:1524::o:0;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;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;59206:3874::-;59296:8;;;;44402:29;59296:8;44402:19;:29::i;:::-;59325:14:::1;::::0;::::1;::::0;::::1;;;::::0;:43:::1;;-1:-1:-1::0;;;;;;59343:25:0;::::1;;::::0;;;:19:::1;:25;::::0;;;;;::::1;;59325:43;:70;;;-1:-1:-1::0;;;;;;59372:23:0;::::1;;::::0;;;:19:::1;:23;::::0;;;;;::::1;;59325:70;59317:109;;;::::0;-1:-1:-1;;;59317:109:0;;15826:2:1;59317:109:0::1;::::0;::::1;15808:21:1::0;15865:2;15845:18;;;15838:30;15904:28;15884:18;;;15877:56;15950:18;;59317:109:0::1;15624:350:1::0;59317:109:0::1;-1:-1:-1::0;;;;;59502:16:0;::::1;::::0;;::::1;::::0;:39:::1;;-1:-1:-1::0;59528:13:0::1;::::0;-1:-1:-1;;;;;59522:19:0;;::::1;59528:13:::0;::::1;59522:19;;59502:39;:67;;;;-1:-1:-1::0;;;;;;59546:23:0;::::1;;::::0;;;:19:::1;:23;::::0;;;;;::::1;;59545:24;59502:67;:97;;;;-1:-1:-1::0;;;;;;59574:25:0;::::1;;::::0;;;:19:::1;:25;::::0;;;;;::::1;;59573:26;59502:97;59498:507;;;59658:12;::::0;-1:-1:-1;;;;;59640:15:0;::::1;;::::0;;;:11:::1;:15;::::0;;;;;:30:::1;::::0;59658:12;59640:30:::1;:::i;:::-;59624:12;:46;;59616:93;;;::::0;-1:-1:-1;;;59616:93:0;;16181:2:1;59616:93:0::1;::::0;::::1;16163:21:1::0;16220:2;16200:18;;;16193:30;16259:34;16239:18;;;16232:62;-1:-1:-1;;;16310:18:1;;;16303:32;16352:19;;59616:93:0::1;15979:398:1::0;59616:93:0::1;-1:-1:-1::0;;;;;14653:18:0;;59724:15:::1;14653:18:::0;;;;;;;;;;;59798:9:::1;::::0;59778:16:::1;59788:6:::0;14653:18;59778:16:::1;:::i;:::-;:29;;59770:80;;;::::0;-1:-1:-1;;;59770:80:0;;16584:2:1;59770:80:0::1;::::0;::::1;16566:21:1::0;16623:2;16603:18;;;16596:30;16662:34;16642:18;;;16635:62;-1:-1:-1;;;16713:18:1;;;16706:36;16759:19;;59770:80:0::1;16382:402:1::0;59770:80:0::1;59883:11;;59873:6;:21;;59865:83;;;::::0;-1:-1:-1;;;59865:83:0;;16991:2:1;59865:83:0::1;::::0;::::1;16973:21:1::0;17030:2;17010:18;;;17003:30;17069:34;17049:18;;;17042:62;-1:-1:-1;;;17120:18:1;;;17113:47;17177:19;;59865:83:0::1;16789:413:1::0;59865:83:0::1;-1:-1:-1::0;;;;;;59963:15:0;::::1;;::::0;;;:11:::1;:15;::::0;;;;59981:12:::1;59963:30:::0;;59498:507:::1;60066:4;60017:28;14653:18:::0;;;;;;;;;;;60122::::1;::::0;60098:42;::::1;::::0;::::1;::::0;;;60157:20:::1;;-1:-1:-1::0;60169:8:0::1;::::0;::::1;;60168:9;60157:20;:32;;;;-1:-1:-1::0;;;;;;60181:8:0;::::1;;::::0;;;:4:::1;:8;::::0;;;;;::::1;;60157:32;:68;;;;-1:-1:-1::0;60209:15:0::1;::::0;-1:-1:-1;;;;;60193:32:0;;::::1;60209:15:::0;::::1;60193:32;;60157:68;:87;;;;-1:-1:-1::0;40533:6:0;;-1:-1:-1;;;;;60229:15:0;;::::1;40533:6:::0;;60229:15:::1;;60157:87;:104;;;;-1:-1:-1::0;40533:6:0;;-1:-1:-1;;;;;60248:13:0;;::::1;40533:6:::0;;60248:13:::1;;60157:104;:132;;;;-1:-1:-1::0;;;;;;60266:23:0;::::1;;::::0;;;:19:::1;:23;::::0;;;;;::::1;;60265:24;60157:132;:162;;;;-1:-1:-1::0;;;;;;60294:25:0;::::1;;::::0;;;:19:::1;:25;::::0;;;;;::::1;;60293:26;60157:162;60153:2247;;;60336:8;:15:::0;;-1:-1:-1;;60336:15:0::1;60347:4;60336:15;::::0;;60395:12:::1;::::0;60336:8:::1;::::0;60394:94:::1;;60487:1;60394:94;;;60471:12;;60456;;:27;;;;:::i;:::-;60439:12;::::0;60416:35:::1;::::0;:20;:35:::1;:::i;:::-;60415:69;;;;:::i;:::-;60368:120:::0;-1:-1:-1;60503:26:0::1;60532:38;60368:120:::0;60532:20;:38:::1;:::i;:::-;60503:67:::0;-1:-1:-1;60640:27:0::1;60670:19;60688:1;60670:15:::0;:19:::1;:::i;:::-;60640:49:::0;-1:-1:-1;60704:32:0::1;60739:37;60640:49:::0;60739:15;:37:::1;:::i;:::-;60704:72:::0;-1:-1:-1;60818:21:0::1;60793:22;60877:40;60898:19:::0;60877:18;:40:::1;:::i;:::-;60854:63;;60932:30;60949:12;60932:16;:30::i;:::-;60977:18;60998:38;61022:14:::0;60998:21:::1;:38;:::i;:::-;60977:59;;61053:20;61092:1:::0;61077:12:::1;;:16;61076:84;;61159:1;61076:84;;;61143:12;;61128;;:27;;;;:::i;:::-;61111:12;::::0;61098:25:::1;::::0;:10;:25:::1;:::i;:::-;61097:59;;;;:::i;:::-;61053:107:::0;-1:-1:-1;61256:18:0::1;61277:25;61053:107:::0;61277:10;:25:::1;:::i;:::-;61256:46;;61319:18;61368:3;61354:10;;61341;:23;;;;:::i;:::-;61340:31;;;;:::i;:::-;61319:52;;61386:16;61431:3;61419:8;;61406:10;:21;;;;:::i;:::-;61405:29;;;;:::i;:::-;61386:48;;61449:17;61496:3;61483:9;;61470:10;:22;;;;:::i;:::-;61469:30;;;;:::i;:::-;61449:50;;61514:23;61573:3;61554:15;;61541:10;:28;;;;:::i;:::-;61540:36;;;;:::i;:::-;61614:11;::::0;:39:::1;::::0;61514:62;;-1:-1:-1;61594:14:0::1;::::0;-1:-1:-1;;;;;61614:11:0;;::::1;::::0;61638:10;;61594:14;61614:39;61594:14;61614:39;61638:10;61614:11;:39:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61593:60;;;61676:9;61668:48;;;::::0;-1:-1:-1;;;61668:48:0;;12815:2:1;61668:48:0::1;::::0;::::1;12797:21:1::0;12854:2;12834:18;;;12827:30;12893:28;12873:18;;;12866:56;12939:18;;61668:48:0::1;12613:350:1::0;61668:48:0::1;61752:9;::::0;:35:::1;::::0;61734:12:::1;::::0;-1:-1:-1;;;;;61752:9:0::1;::::0;61774:8;;61734:12;61752:35;61734:12;61752:35;61774:8;61752:9;:35:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61733:54;;;61810:7;61802:44;;;::::0;-1:-1:-1;;;61802:44:0;;13170:2:1;61802: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;;61802:44:0::1;12968:348:1::0;61802:44:0::1;61883:10;::::0;:37:::1;::::0;61864:13:::1;::::0;-1:-1:-1;;;;;61883:10:0::1;::::0;61906:9;;61864:13;61883:37;61864:13;61883:37;61906:9;61883:10;:37:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61863:57;;;61943:8;61935:46;;;::::0;-1:-1:-1;;;61935:46:0;;13523:2:1;61935: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;;61935:46:0::1;13321:349:1::0;61935:46:0::1;62024:16;::::0;:49:::1;::::0;61999:19:::1;::::0;-1:-1:-1;;;;;62024:16:0::1;::::0;62053:15;;61999:19;62024:49;61999:19;62024:49;62053:15;62024:16;:49:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61998:75;;;62096:14;62088:58;;;::::0;-1:-1:-1;;;62088:58:0;;13877:2:1;62088:58:0::1;::::0;::::1;13859:21:1::0;13916:2;13896:18;;;13889:30;13955:33;13935:18;;;13928:61;14006:18;;62088:58:0::1;13675:355:1::0;62088:58:0::1;62208:12;::::0;:16;62204:109:::1;;62245:52;62258:24;62284:12;62245;:52::i;:::-;62334:21;::::0;1518:25:1;;;62334:21:0::1;::::0;1506:2:1;1491:18;62334:21:0::1;;;;;;;-1:-1:-1::0;;62372:8:0::1;:16:::0;;-1:-1:-1;;62372:16:0::1;::::0;;-1:-1:-1;;;;;;;;;;;;;;;60153:2247:0::1;62428:8;::::0;-1:-1:-1;;;;;62453:25:0;::::1;62412:12;62453:25:::0;;;:19:::1;:25;::::0;;;;;62428:8:::1;::::0;;::::1;62427:9;::::0;62453:25:::1;::::0;:52:::1;;-1:-1:-1::0;;;;;;62482:23:0;::::1;;::::0;;;:19:::1;:23;::::0;;;;;::::1;;62453:52;62449:100;;;-1:-1:-1::0;62532:5:0::1;62449:100;62565:7;62561:468;;;-1:-1:-1::0;;;;;62631:8:0;::::1;62589:17;62631:8:::0;;;:4:::1;:8;::::0;;;;;::::1;;62627:238;;;62723:4;62706:12;;62691;;:27;;;;:::i;:::-;62681:38;::::0;:6;:38:::1;:::i;:::-;62680:47;;;;:::i;:::-;62668:59;;62627:238;;;-1:-1:-1::0;;;;;62753:10:0;::::1;;::::0;;;:4:::1;:10;::::0;;;;;::::1;;62749:116;;;62845:4;62828:12;;62814:11;;:26;;;;:::i;:::-;62804:37;::::0;:6;:37:::1;:::i;:::-;62803:46;;;;:::i;:::-;62791:58;;62749:116;62885:13:::0;;62881:137:::1;;62919:19;62929:9:::0;62919:19;::::1;:::i;:::-;;;62957:45;62971:4;62985;62992:9;62957:13;:45::i;:::-;62574:455;62561:468;63041:31;63055:4;63061:2;63065:6;63041:13;:31::i;:::-;59306:3774;;;44454:20:::0;43724:1;45022:7;:21;44839:212;44490:341;43767:1;44632:7;;:18;:31;;;;;44655:8;44654:9;44632:31;44628:101;;;44687:30;;-1:-1:-1;;;44687:30:0;;;;;;;;;;;44628:101;-1:-1:-1;43767:1:0;44806:7;:17;44490:341::o;63212:702::-;63300:1;63286:11;:15;63278:66;;;;-1:-1:-1;;;63278:66:0;;17542:2:1;63278:66:0;;;17524:21:1;17581:2;17561:18;;;17554:30;17620:34;17600:18;;;17593:62;-1:-1:-1;;;17671:18:1;;;17664:36;17717:19;;63278:66:0;17340:402:1;63278:66:0;63381:4;14626:7;14653:18;;;;;;;;;;;63391:11;-1:-1:-1;63363:39:0;63355:83;;;;-1:-1:-1;;;63355:83:0;;17949:2:1;63355:83:0;;;17931:21:1;17988:2;17968:18;;;17961:30;18027:33;18007:18;;;18000:61;18078:18;;63355:83:0;17747:355:1;63355:83:0;63475:16;;;63489:1;63475:16;;;;;;;;63451:21;;63475:16;;;;;;;;;;-1:-1:-1;63475:16:0;63451:40;;63520:4;63502;63507:1;63502:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;63502:23:0;;;:7;;;;;;;;;;:23;;;;63546:15;;:22;;;-1:-1:-1;;;63546:22:0;;;;:15;;;;;:20;;:22;;;;;63502:7;;63546:22;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63536:4;63541:1;63536:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;63536:32:0;;;:7;;;;;;;;;:32;63613:15;;63581:62;;63598:4;;63613:15;63631:11;63581:8;:62::i;:::-;63682:15;;:224;;-1:-1:-1;;;63682:224:0;;-1:-1:-1;;;;;63682:15:0;;;;:66;;:224;;63763:11;;63682:15;;63833:4;;63860;;63880:15;;63682:224;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63267:647;63212:702;:::o;64073:446::-;64186:15;;64154:62;;64171:4;;-1:-1:-1;;;;;64186:15:0;64204:11;64154:8;:62::i;:::-;64259:15;;-1:-1:-1;;;;;64259:15:0;:31;64298:9;64331:4;64351:11;64259:15;;64463:7;40533:6;;-1:-1:-1;;;;;40533:6:0;;40460:87;64463:7;64259:252;;;;;;-1:-1:-1;;;;;;64259:252:0;;;-1:-1:-1;;;;;19271:32:1;;;64259:252:0;;;19253:51:1;19320:18;;;19313:34;;;;19363:18;;;19356:34;;;;19406:18;;;19399:34;19470:32;;;19449:19;;;19442:61;64485:15:0;19519:19:1;;;19512:35;19225:19;;64259:252:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;64073: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;17207:128::-;17274:9;;;17295:11;;;17292:37;;;17309:18;;:::i;18107:251::-;18177:6;18230:2;18218:9;18209:7;18205:23;18201:32;18198:52;;;18246:1;18243;18236:12;18198:52;18278:9;18272:16;18297:31;18322:5;18297:31;:::i;18363:582::-;18662:6;18651:9;18644:25;18705:6;18700:2;18689:9;18685:18;18678:34;18748:3;18743:2;18732:9;18728:18;18721:31;18625:4;18769:57;18821:3;18810:9;18806:19;18798:6;18769:57;:::i;:::-;-1:-1:-1;;;;;18862:32:1;;;;18857:2;18842:18;;18835:60;-1:-1:-1;18926:3:1;18911:19;18904:35;18761:65;18363:582;-1:-1:-1;;;18363:582:1:o;19558:456::-;19646:6;19654;19662;19715:2;19703:9;19694:7;19690:23;19686:32;19683:52;;;19731:1;19728;19721:12;19683:52;-1:-1:-1;;19776:16:1;;19882:2;19867:18;;19861:25;19978:2;19963:18;;;19957:25;19776:16;;19861:25;;-1:-1:-1;19957:25:1;19558:456;-1:-1:-1;19558:456:1:o

ipfs://f40c7edd1aada51ba71d797d35a6196de95a2e3fdb0cb5a35be2501e48dd74df