Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at lineascan.build/ on 2023-08-21
*/

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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


pragma solidity ^0.8.0;

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

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

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

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

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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


pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


pragma solidity ^0.8.0;

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

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

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


pragma solidity ^0.8.0;



/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * 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.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the 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 override returns (uint8) {
        return 18;
    }

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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


pragma solidity ^0.8.0;

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

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

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


pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

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

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

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

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

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

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

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

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

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

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

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


pragma solidity ^0.8.0;



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

    /**
     * @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.encodeWithSelector(token.transfer.selector, 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.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

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

    /**
     * @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);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

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

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

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

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

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * 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.isContract(address(token));
    }
}


pragma solidity >=0.6.2;

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

    function WETH() external pure returns (address);

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

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

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

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

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

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

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

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

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


// File contracts/interfaces/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;
}


pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }
}


pragma solidity >=0.8.0;

interface IAIERC20BounsPool {
    function initialize(address hub_, address originalToken_, address rewardToken_, address weth_, address router_, uint256 startAt_) external;
    function addReward(uint256 amount) external;
    function rewardToken() external view returns (address);
    function originalToken() external view returns (address);
}


pragma solidity >=0.8.0;

interface IAIERC20TradingPool {
    function initialize(address _originalToken, address _rewardToken, address _router, address _weth, uint256 _startTime, uint256 _epochDuration) external;
    function tradeEvent(address sender, uint256 amount) external;
    function vault() external view returns (address);
    function addCaller(address val) external;
}


// File 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 feeToRate() external view returns (uint256);

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


pragma solidity >=0.5.0;

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

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

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

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

    function deposit() external payable;

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

    function withdraw(uint) external;
}


pragma solidity =0.8.19;











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

    event SwapBack(uint256 burn, uint256 liquidity, uint256 team, uint256 bouns, uint256 trading, uint timestamp);
    event Trade(address user, address pair, uint256 amount, uint side, uint timestamp);
    event AddLiquidity(uint256 tokenAmount, uint256 ethAmount, uint256 timestamp);
    event SetIsFromFeeExempt(address op, address account, bool isExempt);
    event SetIsToFeeExempt(address op, address account, bool isExempt);
    event SetIsSenderFeeExempt(address op, address account, bool isExempt);
    event SetFees(uint256 liquidityFee, uint256 burnFee, uint256 bounsFee, uint256 tradingPoolFee, uint256 teamFee);
    event SetFeeReceivers(address teamWallet, address bounsWallet, address tradingPool);
    event SetTeamWallet(address op, address teamWallet);
    event SetSwapEnabled(address op, bool enabled);
    event AddPair(address op, address pair);
    event RemovePair(address op, address pair);

    enum TaxType {
        None,
        Transfer,
        Trade
    }

    bool public swapEnabled = true;

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

    uint256 public constant FeeDenominator = 10000;
    mapping(address => bool) public isFromFeeExempt;
    mapping(address => bool) public isToFeeExempt;
    mapping(address => bool) public isSenderFeeExempt;

    uint256 public burnFee;
    uint256 public liquidityFee;
    uint256 public teamFee;
    uint256 public bounsFee;
    uint256 public tradingPoolFee;
    uint256 public totalFee;

    address public teamWallet;
    address public bounsWallet;
    IAIERC20TradingPool public tradingPool;

    TaxType public taxType;
    
    IUniswapV2Router02 public immutable swapRouter;
    IUniswapV2Factory public immutable swapFactory;
    IWETH public immutable WETH;
    
    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
    address private constant ZERO = 0x0000000000000000000000000000000000000000;

    EnumerableSet.AddressSet private _pairs;
    EnumerableSet.AddressSet private _fullFeeExempt;
    bool public pairInitialized;

    uint8 private _decimals;

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _taxType,
        uint256 _totalSupply,
        uint8 decimals_,
        address _mintTo,
        address _swapRouter,
        address _swapFactory,
        address _weth
    ) ERC20(_name, _symbol) {
        taxType = TaxType(_taxType);
        _decimals = decimals_;
        isFromFeeExempt[_mintTo] = true;
        isToFeeExempt[_mintTo] = true;
        isSenderFeeExempt[_mintTo] = true;
        isFromFeeExempt[address(this)] = true;
        isToFeeExempt[address(this)] = true;
        isSenderFeeExempt[address(this)] = true;
        isFromFeeExempt[_swapRouter] = true;
        isToFeeExempt[_swapRouter] = true;
        swapRouter = IUniswapV2Router02(_swapRouter);
        swapFactory = IUniswapV2Factory(_swapFactory);
        WETH = IWETH(_weth);
        _mint(_mintTo, _totalSupply);
    }

    function initializePair() external {
        require(!pairInitialized, "pair already initialized");
        address pair = swapFactory.createPair(address(WETH), address(this));
        _pairs.add(pair);
        pairInitialized = true;
    }

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

    function burn(uint256 amount) external {
        _burn(_msgSender(), amount);
    }

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

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

    function _doTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
        if (inSwap) {
            _transfer(sender, recipient, amount);
            return true;
        }

        bool shouldTakeFee = taxType != TaxType.None && (!isSenderFeeExempt[msg.sender] && !isFromFeeExempt[sender] && !isToFeeExempt[recipient]);
        uint side = 0;
        address user_ = sender;
        address pair_ = recipient;

        if (shouldTakeFee) {
            if (isPair(sender)) {
                side = 1;
                user_ = recipient;
                pair_ = sender;
                try tradingPool.tradeEvent(sender, amount) {} catch {}
            } else if (isPair(recipient)) {
                side = 2;
            }
        }

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

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

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

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

    function swapBack() internal swapping {
        uint256 taxAmount = balanceOf(address(this));
        if (taxAmount == 0) return;
        if (totalFee == 0) return;

        _approve(address(this), address(swapRouter), taxAmount);

        uint256 amountBurn = taxAmount * burnFee / totalFee;
        uint256 amountLp = taxAmount * liquidityFee / totalFee;
        uint256 amountBouns = taxAmount * bounsFee / totalFee;
        uint256 amountTrade = taxAmount * tradingPoolFee / totalFee;
        uint256 amountTeam = taxAmount * teamFee / totalFee;
        
        if (amountBurn > 0) {
            _burn(address(this), amountBurn);
        }

        if (amountBouns > 0) {
            _approve(address(this), bounsWallet, amountBouns);
            IAIERC20BounsPool(bounsWallet).addReward(amountBouns);
        }

        if (amountTrade > 0) {
            _transfer(address(this), address(tradingPool.vault()), amountTrade);
        }

        if (amountTeam > 0) {
            _transfer(address(this), teamWallet, amountTeam);
        }

        if (amountLp > 0) {
            _doAddLp();
        }
        
        emit SwapBack(amountBurn, amountLp, amountTeam, amountBouns, amountTrade, block.timestamp);
    }

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

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

        uint256 ethAmountBefore = address(this).balance;
        
        try swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(half, 0, pathEth, address(this),block.timestamp){
            uint256 ethAmount = address(this).balance - ethAmountBefore;

            try swapRouter.addLiquidityETH{value: ethAmount}(address(this), half, 0, 0, address(0), block.timestamp) {
                emit AddLiquidity(half, ethAmount, block.timestamp);
            } catch {}

        } catch {}
    }

    function doSwapBack() public {
        swapBack();
    }

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

    function getLpBalance(address user) public view returns(uint256) {
        address lp = swapFactory.getPair(address(WETH), address(this));
        if (lp == address(0)) {
            return 0;
        }
        return IERC20(lp).balanceOf(user);
    }

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

    function setFees(
        uint256 _liquidityFee,
        uint256 _burnFee,
        uint256 _bounsFee,
        uint256 _tradingPoolFee,
        uint256 _teamFee
    ) external onlyOwner {
        liquidityFee = _liquidityFee;
        burnFee = _burnFee;
        bounsFee = _bounsFee;
        tradingPoolFee = _tradingPoolFee;
        teamFee = _teamFee;
        totalFee = _liquidityFee + _burnFee + _bounsFee + _tradingPoolFee + _teamFee;
        require(totalFee <= 1500, "Invalid fee");
        emit SetFees(liquidityFee, burnFee, bounsFee, tradingPoolFee, teamFee);
    }

    function setFeeReceivers(
        address _bounsWallet,
        address _tradingPool,
        address _teamWallet
    ) external onlyOwner {
        bounsWallet = _bounsWallet;
        tradingPool = IAIERC20TradingPool(_tradingPool);
        teamWallet = _teamWallet;
        emit SetFeeReceivers(_bounsWallet, _tradingPool, _teamWallet);
    }

    function setTeamWallet(address _teamWallet) external {
        require(msg.sender == teamWallet, "Only team wallet can change team wallet");
        teamWallet = _teamWallet;
        emit SetTeamWallet(msg.sender, _teamWallet);
    }

    function setIsFeeExempt(address holder, bool exempt) external ownerOrTeam {
        isFromFeeExempt[holder] = exempt;
        isToFeeExempt[holder] = exempt;
        isSenderFeeExempt[holder] = exempt;
        if (exempt) {
            _fullFeeExempt.add(holder);
        } else {
            _fullFeeExempt.remove(holder);
        }
        emit SetIsFromFeeExempt(msg.sender, holder, exempt);
        emit SetIsToFeeExempt(msg.sender, holder, exempt);
        emit SetIsSenderFeeExempt(msg.sender, holder, exempt);
    }

    function setSysFeeExempt(address holder) external onlyOwner {
        isFromFeeExempt[holder] = true;
        isToFeeExempt[holder] = true;
        isSenderFeeExempt[holder] = true;
        emit SetIsFromFeeExempt(msg.sender, holder, true);
        emit SetIsToFeeExempt(msg.sender, holder, true);
        emit SetIsSenderFeeExempt(msg.sender, holder, true);
    }

    function setIsFromFeeExempt(address holder, bool exempt) external ownerOrTeam {
        isFromFeeExempt[holder] = exempt;
        emit SetIsFromFeeExempt(msg.sender, holder, exempt);
    }

    function setIsToFeeExempt(address holder, bool exempt) external ownerOrTeam {
        isToFeeExempt[holder] = exempt;
        emit SetIsToFeeExempt(msg.sender, holder, exempt);
    }

    function setIsSenderFeeExempt(address holder, bool exempt) external ownerOrTeam {
        isSenderFeeExempt[holder] = exempt;
        emit SetIsSenderFeeExempt(msg.sender, holder, exempt);
    }

    function getFullFeeExempts() external view returns (address[] memory) {
        return _fullFeeExempt.values();
    }

    function setSwapBackSettings(bool _enabled) external onlyOwner {
        swapEnabled = _enabled;
        emit SetSwapEnabled(msg.sender, _enabled);
    }

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

    function addPair(address pair) public onlyOwner returns (bool) {
        require(pair != address(0), "AIERC20: pair is 0");
        emit AddPair(msg.sender, pair);
        return _pairs.add(pair);
    }

    function delPair(address pair) public onlyOwner returns (bool) {
        require(pair != address(0), "AIERC20: pair is 0");
        emit RemovePair(msg.sender, pair);
        return _pairs.remove(pair);
    }

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

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

    modifier ownerOrTeam() {
        require(msg.sender == owner() || msg.sender == teamWallet, "Only owner or team can call this function");
        _;
    }

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

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint8","name":"_taxType","type":"uint8"},{"internalType":"uint256","name":"_totalSupply","type":"uint256"},{"internalType":"uint8","name":"decimals_","type":"uint8"},{"internalType":"address","name":"_mintTo","type":"address"},{"internalType":"address","name":"_swapRouter","type":"address"},{"internalType":"address","name":"_swapFactory","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AddLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"op","type":"address"},{"indexed":false,"internalType":"address","name":"pair","type":"address"}],"name":"AddPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"op","type":"address"},{"indexed":false,"internalType":"address","name":"pair","type":"address"}],"name":"RemovePair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"teamWallet","type":"address"},{"indexed":false,"internalType":"address","name":"bounsWallet","type":"address"},{"indexed":false,"internalType":"address","name":"tradingPool","type":"address"}],"name":"SetFeeReceivers","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"liquidityFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"burnFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"bounsFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tradingPoolFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"teamFee","type":"uint256"}],"name":"SetFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"op","type":"address"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExempt","type":"bool"}],"name":"SetIsFromFeeExempt","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"op","type":"address"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExempt","type":"bool"}],"name":"SetIsSenderFeeExempt","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"op","type":"address"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExempt","type":"bool"}],"name":"SetIsToFeeExempt","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"op","type":"address"},{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"SetSwapEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"op","type":"address"},{"indexed":false,"internalType":"address","name":"teamWallet","type":"address"}],"name":"SetTeamWallet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"burn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"liquidity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"team","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"bouns","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"trading","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"SwapBack","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"side","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Trade","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"FeeDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"contract IWETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"addPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bounsFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bounsWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burnFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clearStuckEthBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"delPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"doSwapBack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCirculatingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFullFeeExempts","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getLpBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPairsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inSwap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initializePair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isFromFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isSenderFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isToFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pairInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_bounsWallet","type":"address"},{"internalType":"address","name":"_tradingPool","type":"address"},{"internalType":"address","name":"_teamWallet","type":"address"}],"name":"setFeeReceivers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_liquidityFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"},{"internalType":"uint256","name":"_bounsFee","type":"uint256"},{"internalType":"uint256","name":"_tradingPoolFee","type":"uint256"},{"internalType":"uint256","name":"_teamFee","type":"uint256"}],"name":"setFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsFromFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsSenderFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsToFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setSwapBackSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"}],"name":"setSysFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_teamWallet","type":"address"}],"name":"setTeamWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapFactory","outputs":[{"internalType":"contract IUniswapV2Factory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapRouter","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxType","outputs":[{"internalType":"enum AIERC20.TaxType","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFee","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":"tradingPool","outputs":[{"internalType":"contract IAIERC20TradingPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingPoolFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000052b7d2dcc80cd2e400000000000000000000000000000000000000000000000000000000000000000000120000000000000000000000005b147c50a6154169cb34b6bd6e09c5429c452133000000000000000000000000c66149996d0263c0b42d3bc05e50db88658106ce0000000000000000000000006d1063f2187442cc9adbfad2f55a96b846fcb399000000000000000000000000e5d7c2a44ffddf6b295a15c148167daaaf5cf34f0000000000000000000000000000000000000000000000000000000000000004546573740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000045445535400000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Test
Arg [1] : _symbol (string): TEST
Arg [2] : _taxType (uint8): 1
Arg [3] : _totalSupply (uint256): 100000000000000000000000000
Arg [4] : decimals_ (uint8): 18
Arg [5] : _mintTo (address): 0x5B147C50A6154169cB34b6bd6e09c5429c452133
Arg [6] : _swapRouter (address): 0xc66149996d0263C0B42D3bC05e50Db88658106cE
Arg [7] : _swapFactory (address): 0x6D1063F2187442Cc9adbFAD2f55A96B846FCB399
Arg [8] : _weth (address): 0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f

-----Encoded View---------------
13 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [3] : 00000000000000000000000000000000000000000052b7d2dcc80cd2e4000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [5] : 0000000000000000000000005b147c50a6154169cb34b6bd6e09c5429c452133
Arg [6] : 000000000000000000000000c66149996d0263c0b42d3bc05e50db88658106ce
Arg [7] : 0000000000000000000000006d1063f2187442cc9adbfad2f55a96b846fcb399
Arg [8] : 000000000000000000000000e5d7c2a44ffddf6b295a15c148167daaaf5cf34f
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [10] : 5465737400000000000000000000000000000000000000000000000000000000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [12] : 5445535400000000000000000000000000000000000000000000000000000000

57473:12575:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65724:589;;;;;;;;;;-1:-1:-1;65724:589:0;;;;;:::i;:::-;;:::i;:::-;;8732:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11092:201;;;;;;;;;;-1:-1:-1;11092:201:0;;;;;:::i;:::-;;:::i;:::-;;;1750:14:1;;1743:22;1725:41;;1713:2;1698:18;11092:201:0;1585:187:1;59213:26:0;;;;;;;;;;-1:-1:-1;59213:26:0;;;;-1:-1:-1;;;;;59213:26:0;;;;;;-1:-1:-1;;;;;1941:32:1;;;1923:51;;1911:2;1896:18;59213:26:0;1777:203:1;67848:191:0;;;;;;;;;;-1:-1:-1;67848:191:0;;;;;:::i;:::-;;:::i;66682:237::-;;;;;;;;;;-1:-1:-1;66682:237:0;;;;;:::i;:::-;;:::i;9861:108::-;;;;;;;;;;-1:-1:-1;9949:12:0;;9861:108;;;2868:25:1;;;2856:2;2841:18;9861:108:0;2722:177:1;68047:185:0;;;;;;;;;;-1:-1:-1;68047:185:0;;;;;:::i;:::-;;:::i;59149:23::-;;;;;;;;;;;;;;;;61338:268;;;;;;;;;;-1:-1:-1;61338:268:0;;;;;:::i;:::-;;:::i;65579:137::-;;;;;;;;;;;;;:::i;58774:46::-;;;;;;;;;;;;58815:5;58774:46;;60981:100;;;;;;;;;;-1:-1:-1;61064:9:0;;;;;;;60981:100;;3537:4:1;3525:17;;;3507:36;;3495:2;3480:18;60981:100:0;3365:184:1;58881:45:0;;;;;;;;;;-1:-1:-1;58881:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;12543:238;;;;;;;;;;-1:-1:-1;12543:238:0;;;;;:::i;:::-;;:::i;61089:85::-;;;;;;;;;;-1:-1:-1;61089:85:0;;;;;:::i;:::-;;:::i;60728:245::-;;;;;;;;;;;;;:::i;59181:25::-;;;;;;;;;;-1:-1:-1;59181:25:0;;;;-1:-1:-1;;;;;59181:25:0;;;67469:371;;;;;;;;;;-1:-1:-1;67469:371:0;;;;;:::i;:::-;;:::i;66927:534::-;;;;;;;;;;-1:-1:-1;66927:534:0;;;;;:::i;:::-;;:::i;58613:30::-;;;;;;;;;;-1:-1:-1;58613:30:0;;;;-1:-1:-1;;;58613:30:0;;;;;;10032:127;;;;;;;;;;-1:-1:-1;10032:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;10133:18:0;10106:7;10133:18;;;;;;;;;;;;10032:127;2617:103;;;;;;;;;;;;;:::i;59246:38::-;;;;;;;;;;-1:-1:-1;59246:38:0;;;;-1:-1:-1;;;;;59246:38:0;;;59381:46;;;;;;;;;;;;;;;69288:97;;;;;;;;;;;;;:::i;1976:87::-;;;;;;;;;;-1:-1:-1;2049:6:0;;-1:-1:-1;;;;;2049:6:0;1976:87;;64999:58;;;;;;;;;;;;;:::i;59738:27::-;;;;;;;;;;-1:-1:-1;59738:27:0;;;;;;;;8951:104;;;;;;;;;;;;;:::i;59020:27::-;;;;;;;;;;;;;;;;68445:119;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;13284:436::-;;;;;;;;;;-1:-1:-1;13284:436:0;;;;;:::i;:::-;;:::i;69068:212::-;;;;;;;;;;-1:-1:-1;69068:212:0;;;;;:::i;:::-;;:::i;61182:148::-;;;;;;;;;;-1:-1:-1;61182:148:0;;;;;:::i;:::-;;:::i;65314:257::-;;;;;;;;;;-1:-1:-1;65314:257:0;;;;;:::i;:::-;;:::i;59434:27::-;;;;;;;;;;;;;;;58827:47;;;;;;;;;;-1:-1:-1;58827:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;68572:156;;;;;;;;;;-1:-1:-1;68572:156:0;;;;;:::i;:::-;;:::i;69393:184::-;;;;;;;;;;-1:-1:-1;69393:184:0;;;;;:::i;:::-;;:::i;69750:258::-;;;;;;;;;;;;;:::i;68854:206::-;;;;;;;;;;-1:-1:-1;68854:206:0;;;;;:::i;:::-;;:::i;59328:46::-;;;;;;;;;;;;;;;58933:49;;;;;;;;;;-1:-1:-1;58933:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;66321:353;;;;;;;;;;-1:-1:-1;66321:353:0;;;;;:::i;:::-;;:::i;59054:22::-;;;;;;;;;;;;;;;;58652:18;;;;;;;;;;-1:-1:-1;58652:18:0;;;;-1:-1:-1;;;58652:18:0;;;;;;59113:29;;;;;;;;;;;;;;;;10621:151;;;;;;;;;;-1:-1:-1;10621:151:0;;;;;:::i;:::-;;:::i;68736:110::-;;;;;;;;;;-1:-1:-1;68736:110:0;;;;;:::i;:::-;;:::i;59293:22::-;;;;;;;;;;-1:-1:-1;59293:22:0;;;;-1:-1:-1;;;59293:22:0;;;;;;;;;;;;;:::i;2875:201::-;;;;;;;;;;-1:-1:-1;2875:201:0;;;;;:::i;:::-;;:::i;59083:23::-;;;;;;;;;;;;;;;;58991:22;;;;;;;;;;;;;;;;68240:197;;;;;;;;;;-1:-1:-1;68240:197:0;;;;;:::i;:::-;;:::i;65724:589::-;1862:13;:11;:13::i;:::-;65926:12:::1;:28:::0;;;65965:7:::1;:18:::0;;;65994:8:::1;:20:::0;;;66025:14:::1;:32:::0;;;66068:7:::1;:18:::0;;;66078:8;66042:15;66005:9;66108:24:::1;65975:8:::0;65941:13;66108:24:::1;:::i;:::-;:36;;;;:::i;:::-;:54;;;;:::i;:::-;:65;;;;:::i;:::-;66097:8;:76:::0;;;66204:4:::1;-1:-1:-1::0;66192:16:0::1;66184:40;;;::::0;-1:-1:-1;;;66184:40:0;;7451:2:1;66184:40:0::1;::::0;::::1;7433:21:1::0;7490:2;7470:18;;;7463:30;-1:-1:-1;;;7509:18:1;;;7502:41;7560:18;;66184:40:0::1;;;;;;;;;66248:12;::::0;66262:7:::1;::::0;66271:8:::1;::::0;66281:14:::1;::::0;66297:7:::1;::::0;66240:65:::1;::::0;;7848:25:1;;;7904:2;7889:18;;7882:34;;;;7932:18;;;7925:34;;;;7990:2;7975:18;;7968:34;8033:3;8018:19;;8011:35;66240:65:0::1;::::0;7835:3:1;7820:19;66240:65:0::1;;;;;;;;65724:589:::0;;;;;:::o;8732:100::-;8786:13;8819:5;8812:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8732:100;:::o;11092:201::-;11175:4;736:10;11231:32;736:10;11247:7;11256:6;11231:8;:32::i;:::-;11281:4;11274:11;;;11092:201;;;;;:::o;67848:191::-;2049:6;;-1:-1:-1;;;;;2049:6:0;69627:10;:21;;:49;;-1:-1:-1;69666:10:0;;-1:-1:-1;;;;;69666:10:0;69652;:24;69627:49;69619:103;;;;-1:-1:-1;;;69619:103:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;67937:23:0;::::1;;::::0;;;:15:::1;:23;::::0;;;;;;:32;;-1:-1:-1;;67937:32:0::1;::::0;::::1;;;::::0;;67985:46;::::1;::::0;::::1;::::0;68004:10:::1;::::0;67937:23;;:32;;67985:46:::1;:::i;:::-;;;;;;;;67848:191:::0;;:::o;66682:237::-;66768:10;;-1:-1:-1;;;;;66768:10:0;66754;:24;66746:76;;;;-1:-1:-1;;;66746:76:0;;9444:2:1;66746:76:0;;;9426:21:1;9483:2;9463:18;;;9456:30;9522:34;9502:18;;;9495:62;-1:-1:-1;;;9573:18:1;;;9566:37;9620:19;;66746:76:0;9242:403:1;66746:76:0;66833:10;:24;;-1:-1:-1;;;;;;66833:24:0;-1:-1:-1;;;;;66833:24:0;;;;;;;;66873:38;;;66887:10;9862:34:1;;9927:2;9912:18;;9905:43;;;;66873:38:0;;9797:18:1;66873:38:0;;;;;;;;66682:237;:::o;68047:185::-;2049:6;;-1:-1:-1;;;;;2049:6:0;69627:10;:21;;:49;;-1:-1:-1;69666:10:0;;-1:-1:-1;;;;;69666:10:0;69652;:24;69627:49;69619:103;;;;-1:-1:-1;;;69619:103:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;68134:21:0;::::1;;::::0;;;:13:::1;:21;::::0;;;;;;:30;;-1:-1:-1;;68134:30:0::1;::::0;::::1;;;::::0;;68180:44;::::1;::::0;::::1;::::0;68197:10:::1;::::0;68134:21;;:30;;68180:44:::1;:::i;61338:268::-:0;61444:4;736:10;61502:40;61518:6;736:10;61535:6;61502:15;:40::i;:::-;61560:38;61572:6;61580:9;61591:6;61560:11;:38::i;:::-;61553:45;;;61338:268;;;;;;:::o;65579:137::-;65632:7;10133:18;;;;;;59506:42;10133:18;;;;9949:12;;65659:31;;10133:18;65659:31;:::i;:::-;:49;;;;:::i;:::-;65652:56;;65579:137;:::o;12543:238::-;12631:4;736:10;12687:64;736:10;12703:7;12740:10;12712:25;736:10;12703:7;12712:9;:25::i;:::-;:38;;;;:::i;:::-;12687:8;:64::i;61089:85::-;61139:27;736:10;61159:6;61139:5;:27::i;:::-;61089:85;:::o;60728:245::-;60783:15;;;;60782:16;60774:53;;;;-1:-1:-1;;;60774:53:0;;10294:2:1;60774:53:0;;;10276:21:1;10333:2;10313:18;;;10306:30;10372:26;10352:18;;;10345:54;10416:18;;60774:53:0;10092:348:1;60774:53:0;60853:52;;-1:-1:-1;;;60853:52:0;;-1:-1:-1;;;;;60884:4:0;9880:15:1;;60853:52:0;;;9862:34:1;60899:4:0;9912:18:1;;;9905:43;-1:-1:-1;;60853:11:0;:22;;;;;;9797:18:1;;60853:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60838:67;-1:-1:-1;60916:16:0;:6;60838:67;60916:10;:16::i;:::-;-1:-1:-1;;60943:15:0;:22;;-1:-1:-1;;60943:22:0;60961:4;60943:22;;;60728:245::o;67469:371::-;1862:13;:11;:13::i;:::-;-1:-1:-1;;;;;67540:23:0;::::1;;::::0;;;:15:::1;:23;::::0;;;;;;;:30;;67566:4:::1;-1:-1:-1::0;;67540:30:0;;::::1;::::0;::::1;::::0;;;67581:13:::1;:21:::0;;;;;:28;;;::::1;::::0;::::1;::::0;;67620:17:::1;:25:::0;;;;;;;:32;;;;::::1;::::0;::::1;::::0;;;67668:44;::::1;::::0;::::1;::::0;67687:10:::1;::::0;67540:23;;67668:44:::1;:::i;:::-;;;;;;;;67728:42;67745:10;67757:6;67765:4;67728:42;;;;;;;;:::i;:::-;;;;;;;;67786:46;67807:10;67819:6;67827:4;67786:46;;;;;;;;:::i;66927:534::-:0;2049:6;;-1:-1:-1;;;;;2049:6:0;69627:10;:21;;:49;;-1:-1:-1;69666:10:0;;-1:-1:-1;;;;;69666:10:0;69652;:24;69627:49;69619:103;;;;-1:-1:-1;;;69619:103:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;67012:23:0;::::1;;::::0;;;:15:::1;:23;::::0;;;;;;;:32;;;::::1;::::0;::::1;-1:-1:-1::0;;67012:32:0;;::::1;::::0;::::1;::::0;;;67055:13:::1;:21:::0;;;;;:30;;;::::1;::::0;::::1;::::0;;67096:17:::1;:25:::0;;;;;;;:34;;;;::::1;::::0;;::::1;::::0;;;67141:127:::1;;67168:26;:14;67187:6:::0;67168:18:::1;:26::i;:::-;;67141:127;;;67227:29;:14;67249:6:::0;67227:21:::1;:29::i;:::-;;67141:127;67283:46;67302:10;67314:6;67322;67283:46;;;;;;;;:::i;:::-;;;;;;;;67345:44;67362:10;67374:6;67382;67345:44;;;;;;;;:::i;:::-;;;;;;;;67405:48;67426:10;67438:6;67446;67405:48;;;;;;;;:::i;2617:103::-:0;1862:13;:11;:13::i;:::-;2682:30:::1;2709:1;2682:18;:30::i;:::-;2617:103::o:0;69288:97::-;69335:7;69362:15;:6;:13;:15::i;64999:58::-;65039:10;:8;:10::i;8951:104::-;9007:13;9040:7;9033:14;;;;;:::i;68445:119::-;68497:16;68533:23;:14;:21;:23::i;13284:436::-;13377:4;736:10;13377:4;13460:25;736:10;13477:7;13460:9;:25::i;:::-;13433:52;;13524:15;13504:16;:35;;13496:85;;;;-1:-1:-1;;;13496:85:0;;10903:2:1;13496:85:0;;;10885:21:1;10942:2;10922:18;;;10915:30;10981:34;10961:18;;;10954:62;-1:-1:-1;;;11032:18:1;;;11025:35;11077:19;;13496:85:0;10701:401:1;13496:85:0;13617:60;13626:5;13633:7;13661:15;13642:16;:34;13617:8;:60::i;:::-;-1:-1:-1;13708:4:0;;13284:436;-1:-1:-1;;;;13284:436:0:o;69068:212::-;69125:4;1862:13;:11;:13::i;:::-;-1:-1:-1;;;;;69150:18:0;::::1;69142:49;;;::::0;-1:-1:-1;;;69142:49:0;;11309:2:1;69142:49:0::1;::::0;::::1;11291:21:1::0;11348:2;11328:18;;;11321:30;-1:-1:-1;;;11367:18:1;;;11360:48;11425:18;;69142:49:0::1;11107:342:1::0;69142:49:0::1;69207:28;::::0;;69218:10:::1;9862:34:1::0;;-1:-1:-1;;;;;9932:15:1;;9927:2;9912:18;;9905:43;69207:28:0::1;::::0;9797:18:1;69207:28:0::1;;;;;;;69253:19;:6;69267:4:::0;69253:13:::1;:19::i;:::-;69246:26;;1886:1;69068:212:::0;;;:::o;61182:148::-;61261:4;61285:37;736:10;61311:2;61315:6;61285:11;:37::i;65314:257::-;65403:49;;-1:-1:-1;;;65403:49:0;;-1:-1:-1;;;;;65431:4:0;9880:15:1;;65403:49:0;;;9862:34:1;65446:4:0;9912:18:1;;;9905:43;-1:-1:-1;;;;65403:11:0;:19;;;;9797:18:1;;65403:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65390:62;-1:-1:-1;;;;;;65467:16:0;;65463:57;;-1:-1:-1;65507:1:0;;65314:257;-1:-1:-1;;65314:257:0:o;65463:57::-;65537:26;;-1:-1:-1;;;65537:26:0;;-1:-1:-1;;;;;1941:32:1;;;65537:26:0;;;1923:51:1;65537:20:0;;;;;1896:18:1;;65537:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;68572:156::-;1862:13;:11;:13::i;:::-;68646:11:::1;:22:::0;;-1:-1:-1;;;;68646:22:0::1;-1:-1:-1::0;;;68646:22:0;::::1;;::::0;;::::1;::::0;;;::::1;::::0;;;68684:36:::1;::::0;;68699:10:::1;11811:51:1::0;;11893:2;11878:18;;11871:50;;;;68684:36:0::1;::::0;11784:18:1;68684:36:0::1;11643:284:1::0;69393:184:0;69446:7;69501:1;69483:15;:6;:13;:15::i;:::-;:19;;;;:::i;:::-;69474:5;:28;;69466:69;;;;-1:-1:-1;;;69466:69:0;;12134:2:1;69466:69:0;;;12116:21:1;12173:2;12153:18;;;12146:30;12212;12192:18;;;12185:58;12260:18;;69466:69:0;11932:352:1;69466:69:0;69553:16;:6;69563:5;69553:9;:16::i;69750:258::-;1862:13;:11;:13::i;:::-;69928:12:::1;::::0;;69812:17:::1;69928:12:::0;;;::::1;::::0;::::1;::::0;;;;69832:21:::1;::::0;69812:17;;736:10;;69832:21;;69883:58:::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69864:77;;;69960:7;69952:48;;;::::0;-1:-1:-1;;;69952:48:0;;12915:2:1;69952:48:0::1;::::0;::::1;12897:21:1::0;12954:2;12934:18;;;12927:30;12993;12973:18;;;12966:58;13041:18;;69952:48:0::1;12713:352:1::0;69952:48:0::1;69801:207;;69750:258::o:0;68854:206::-;68911:4;1862:13;:11;:13::i;:::-;-1:-1:-1;;;;;68936:18:0;::::1;68928:49;;;::::0;-1:-1:-1;;;68928:49:0;;11309:2:1;68928:49:0::1;::::0;::::1;11291:21:1::0;11348:2;11328:18;;;11321:30;-1:-1:-1;;;11367:18:1;;;11360:48;11425:18;;68928:49:0::1;11107:342:1::0;68928:49:0::1;68993:25;::::0;;69001:10:::1;9862:34:1::0;;-1:-1:-1;;;;;9932:15:1;;9927:2;9912:18;;9905:43;68993:25:0::1;::::0;9797:18:1;68993:25:0::1;;;;;;;69036:16;:6;69047:4:::0;69036:10:::1;:16::i;66321:353::-:0;1862:13;:11;:13::i;:::-;66475:11:::1;:26:::0;;-1:-1:-1;;;;;66475:26:0;;::::1;-1:-1:-1::0;;;;;;66475:26:0;;::::1;::::0;::::1;::::0;;;66512:11:::1;:47:::0;;;;::::1;::::0;;::::1;::::0;::::1;::::0;;;66570:10:::1;:24:::0;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;;66610:56:::1;::::0;;13310:34:1;;;13375:2;13360:18;;13353:43;;;;13412:18;;;13405:43;66610:56:0::1;::::0;13260:2:1;13245:18;66610:56:0::1;;;;;;;66321:353:::0;;;:::o;10621:151::-;-1:-1:-1;;;;;10737:18:0;;;10710:7;10737:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;10621:151::o;68736:110::-;68790:4;68814:24;:6;68830:7;68814:15;:24::i;2875:201::-;1862:13;:11;:13::i;:::-;-1:-1:-1;;;;;2964:22:0;::::1;2956:73;;;::::0;-1:-1:-1;;;2956:73:0;;13661:2:1;2956:73:0::1;::::0;::::1;13643:21:1::0;13700:2;13680:18;;;13673:30;13739:34;13719:18;;;13712:62;-1:-1:-1;;;13790:18:1;;;13783:36;13836:19;;2956:73:0::1;13459:402:1::0;2956:73:0::1;3040:28;3059:8;3040:18;:28::i;68240:197::-:0;2049:6;;-1:-1:-1;;;;;2049:6:0;69627:10;:21;;:49;;-1:-1:-1;69666:10:0;;-1:-1:-1;;;;;69666:10:0;69652;:24;69627:49;69619:103;;;;-1:-1:-1;;;69619:103:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;68331:25:0;::::1;;::::0;;;:17:::1;:25;::::0;;;;;;:34;;-1:-1:-1;;68331:34:0::1;::::0;::::1;;;::::0;;68381:48;::::1;::::0;::::1;::::0;68402:10:::1;::::0;68331:25;;:34;;68381:48:::1;:::i;2141:132::-:0;2049:6;;-1:-1:-1;;;;;2049:6:0;736:10;2205:23;2197:68;;;;-1:-1:-1;;;2197:68:0;;14068:2:1;2197:68:0;;;14050:21:1;;;14087:18;;;14080:30;14146:34;14126:18;;;14119:62;14198:18;;2197:68:0;13866:356:1;17277:346:0;-1:-1:-1;;;;;17379:19:0;;17371:68;;;;-1:-1:-1;;;17371:68:0;;14429:2:1;17371:68:0;;;14411:21:1;14468:2;14448:18;;;14441:30;14507:34;14487:18;;;14480:62;-1:-1:-1;;;14558:18:1;;;14551:34;14602:19;;17371:68:0;14227:400:1;17371:68:0;-1:-1:-1;;;;;17458:21:0;;17450:68;;;;-1:-1:-1;;;17450:68:0;;14834:2:1;17450:68:0;;;14816:21:1;14873:2;14853:18;;;14846:30;14912:34;14892:18;;;14885:62;-1:-1:-1;;;14963:18:1;;;14956:32;15005:19;;17450:68:0;14632:398:1;17450:68:0;-1:-1:-1;;;;;17531:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;17583:32;;2868:25:1;;;17583:32:0;;2841:18:1;17583:32:0;;;;;;;;17277:346;;;:::o;17914:419::-;18015:24;18042:25;18052:5;18059:7;18042:9;:25::i;:::-;18015:52;;-1:-1:-1;;18082:16:0;:37;18078:248;;18164:6;18144:16;:26;;18136:68;;;;-1:-1:-1;;;18136:68:0;;15237:2:1;18136:68:0;;;15219:21:1;15276:2;15256:18;;;15249:30;15315:31;15295:18;;;15288:59;15364:18;;18136:68:0;15035:353:1;18136:68:0;18248:51;18257:5;18264:7;18292:6;18273:16;:25;18248:8;:51::i;:::-;18004:329;17914:419;;;:::o;61614:1133::-;61725:6;;61704:4;;-1:-1:-1;;;61725:6:0;;;;61721:101;;;61748:36;61758:6;61766:9;61777:6;61748:9;:36::i;:::-;-1:-1:-1;61806:4:0;61799:11;;61721:101;61834:18;;61855:7;;-1:-1:-1;;;61855:7:0;;;;:23;;;;;;;;:::i;:::-;;;:116;;;;-1:-1:-1;61902:10:0;61884:29;;;;:17;:29;;;;;;;;61883:30;:58;;;;-1:-1:-1;;;;;;61918:23:0;;;;;;:15;:23;;;;;;;;61917:24;61883:58;:87;;;;-1:-1:-1;;;;;;61946:24:0;;;;;;:13;:24;;;;;;;;61945:25;61883:87;61834:137;-1:-1:-1;61982:9:0;62022:6;62055:9;62077:321;;;;62115:14;62122:6;62115;:14::i;:::-;62111:276;;;-1:-1:-1;;62250:11:0;;:38;;-1:-1:-1;;;62250:38:0;;-1:-1:-1;;;;;15585:32:1;;;62250:38:0;;;15567:51:1;15634:18;;;15627:34;;;62157:1:0;;-1:-1:-1;62185:9:0;;62221:6;;62250:11;;;:22;;15540:18:1;;62250:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62246:54;62111:276;62246:54;62111:276;;;62325:17;62332:9;62325:6;:17::i;:::-;62321:66;;;62370:1;62363:8;;62321:66;62414:16;:14;:16::i;:::-;62410:59;;;62447:10;:8;:10::i;:::-;62481:22;62506:13;:48;;62548:6;62506:48;;;62522:23;62530:6;62538;62522:7;:23::i;:::-;62481:73;;62565:44;62575:6;62583:9;62594:14;62565:9;:44::i;:::-;62626:8;;62622:96;;62656:50;;;-1:-1:-1;;;;;15987:15:1;;;15969:34;;16039:15;;16034:2;16019:18;;16012:43;16071:18;;;16064:34;;;16129:2;16114:18;;16107:34;;;62690:15:0;16172:3:1;16157:19;;16150:35;62656:50:0;;15918:3:1;15903:19;62656:50:0;;;;;;;62622:96;-1:-1:-1;62735:4:0;;61614:1133;-1:-1:-1;;;;;;;;61614:1133:0:o;16164:675::-;-1:-1:-1;;;;;16248:21:0;;16240:67;;;;-1:-1:-1;;;16240:67:0;;16398:2:1;16240:67:0;;;16380:21:1;16437:2;16417:18;;;16410:30;16476:34;16456:18;;;16449:62;-1:-1:-1;;;16527:18:1;;;16520:31;16568:19;;16240:67:0;16196:397:1;16240:67:0;-1:-1:-1;;;;;16407:18:0;;16382:22;16407:18;;;;;;;;;;;16444:24;;;;16436:71;;;;-1:-1:-1;;;16436:71:0;;16800:2:1;16436:71:0;;;16782:21:1;16839:2;16819:18;;;16812:30;16878:34;16858:18;;;16851:62;-1:-1:-1;;;16929:18:1;;;16922:32;16971:19;;16436:71:0;16598:398:1;16436:71:0;-1:-1:-1;;;;;16543:18:0;;:9;:18;;;;;;;;;;;16564:23;;;16543:44;;16682:12;:22;;;;;;;16733:37;2868:25:1;;;16543:9:0;;:18;16733:37;;2841:18:1;16733:37:0;2722:177:1;50530:152:0;50600:4;50624:50;50629:3;-1:-1:-1;;;;;50649:23:0;;50624:4;:50::i;50858:158::-;50931:4;50955:53;50963:3;-1:-1:-1;;;;;50983:23:0;;50955:7;:53::i;3236:191::-;3329:6;;;-1:-1:-1;;;;;3346:17:0;;;-1:-1:-1;;;;;;3346:17:0;;;;;;;3379:40;;3329:6;;;3346:17;3329:6;;3379:40;;3310:16;;3379:40;3299:128;3236:191;:::o;51355:117::-;51418:7;51445:19;51453:3;46655:18;;46572:109;62923:1255;58708:6;:13;;-1:-1:-1;;;;58708:13:0;-1:-1:-1;;;58708:13:0;;;63010:4:::1;-1:-1:-1::0;10133:18:0;;;;;;;;;;;62972:44:::1;;63031:9;63044:1;63031:14:::0;63027:27:::1;;63047:7;;;63027:27;63068:8;;63080:1;63068:13:::0;63064:26:::1;;63083:7;;;63064:26;63102:55;63119:4;63134:10;63147:9;63102:8;:55::i;:::-;63170:18;63213:8;;63203:7;;63191:9;:19;;;;:::i;:::-;:30;;;;:::i;:::-;63170:51;;63232:16;63278:8;;63263:12;;63251:9;:24;;;;:::i;:::-;:35;;;;:::i;:::-;63232:54;;63297:19;63342:8;;63331;;63319:9;:20;;;;:::i;:::-;:31;;;;:::i;:::-;63297:53;;63361:19;63412:8;;63395:14;;63383:9;:26;;;;:::i;:::-;:37;;;;:::i;:::-;63361:59;;63431:18;63474:8;;63464:7;;63452:9;:19;;;;:::i;:::-;:30;;;;:::i;:::-;63431:51:::0;-1:-1:-1;63507:14:0;;63503:79:::1;;63538:32;63552:4;63559:10;63538:5;:32::i;:::-;63598:15:::0;;63594:165:::1;;63654:11;::::0;63630:49:::1;::::0;63647:4:::1;::::0;-1:-1:-1;;;;;63654:11:0::1;63667::::0;63630:8:::1;:49::i;:::-;63712:11;::::0;63694:53:::1;::::0;-1:-1:-1;;;63694:53:0;;::::1;::::0;::::1;2868:25:1::0;;;-1:-1:-1;;;;;63712:11:0;;::::1;::::0;63694:40:::1;::::0;2841:18:1;;63694:53:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;63594:165;63775:15:::0;;63771:115:::1;;63807:67;63825:4;63840:11;;;;;;;;;-1:-1:-1::0;;;;;63840:11:0::1;-1:-1:-1::0;;;;;63840:17:0::1;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63862:11;63807:9;:67::i;:::-;63902:14:::0;;63898:95:::1;;63958:10;::::0;63933:48:::1;::::0;63951:4:::1;::::0;-1:-1:-1;;;;;63958:10:0::1;63970::::0;63933:9:::1;:48::i;:::-;64009:12:::0;;64005:55:::1;;64038:10;:8;:10::i;:::-;64085:85;::::0;;17683:25:1;;;17739:2;17724:18;;17717:34;;;17767:18;;;17760:34;;;17825:2;17810:18;;17803:34;;;17868:3;17853:19;;17846:35;;;64154:15:0::1;17912:3:1::0;17897:19;;17890:35;64085:85:0::1;::::0;17670:3:1;17655:19;64085:85:0::1;;;;;;;62961:1217;;;;;;58732:1;58744:6:::0;:14;;-1:-1:-1;;;;58744:14:0;;;62923:1255::o;52534:310::-;52597:16;52626:22;52651:19;52659:3;52651:7;:19::i;51826:158::-;51900:7;51951:22;51955:3;51967:5;51951:3;:22::i;51102:167::-;-1:-1:-1;;;;;51236:23:0;;51182:4;46454:19;;;:12;;;:19;;;;;;:24;;51206:55;46357:129;14190:806;-1:-1:-1;;;;;14287:18:0;;14279:68;;;;-1:-1:-1;;;14279:68:0;;18138:2:1;14279:68:0;;;18120:21:1;18177:2;18157:18;;;18150:30;18216:34;18196:18;;;18189:62;-1:-1:-1;;;18267:18:1;;;18260:35;18312:19;;14279:68:0;17936:401:1;14279:68:0;-1:-1:-1;;;;;14366:16:0;;14358:64;;;;-1:-1:-1;;;14358:64:0;;18544:2:1;14358:64:0;;;18526:21:1;18583:2;18563:18;;;18556:30;18622:34;18602:18;;;18595:62;-1:-1:-1;;;18673:18:1;;;18666:33;18716:19;;14358:64:0;18342:399:1;14358:64:0;-1:-1:-1;;;;;14508:15:0;;14486:19;14508:15;;;;;;;;;;;14542:21;;;;14534:72;;;;-1:-1:-1;;;14534:72:0;;18948:2:1;14534:72:0;;;18930:21:1;18987:2;18967:18;;;18960:30;19026:34;19006:18;;;18999:62;-1:-1:-1;;;19077:18:1;;;19070:36;19123:19;;14534:72:0;18746:402:1;14534:72:0;-1:-1:-1;;;;;14642:15:0;;;:9;:15;;;;;;;;;;;14660:20;;;14642:38;;14860:13;;;;;;;;;;:23;;;;;;14912:26;;2868:25:1;;;14860:13:0;;14912:26;;2841:18:1;14912:26:0;;;;;;;14951:37;16164:675;62755:160;62829:6;;62804:4;;-1:-1:-1;;;62829:6:0;;;;62828:7;:22;;;;-1:-1:-1;62839:11:0;;-1:-1:-1;;;62839:11:0;;;;62828:22;:54;;;;-1:-1:-1;62872:4:0;62881:1;10133:18;;;;;;;;;;;62854:28;62828:54;:79;;;;-1:-1:-1;62887:20:0;736:10;68736:110;:::i;62887:20::-;62886:21;62821:86;;62755:160;:::o;65065:241::-;65132:7;65152:17;58815:5;65182:8;;65173:6;:17;;;;:::i;:::-;65172:36;;;;:::i;:::-;65152:56;;65219:43;65229:6;65245:4;65252:9;65219;:43::i;:::-;65280:18;65289:9;65280:6;:18;:::i;:::-;65273:25;65065:241;-1:-1:-1;;;;65065:241:0:o;44261:414::-;44324:4;46454:19;;;:12;;;:19;;;;;;44341:327;;-1:-1:-1;44384:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;44567:18;;44545:19;;;:12;;;:19;;;;;;:40;;;;44600:11;;44341:327;-1:-1:-1;44651:5:0;44644:12;;44851:1420;44917:4;45056:19;;;:12;;;:19;;;;;;45092:15;;45088:1176;;45467:21;45491:14;45504:1;45491:10;:14;:::i;:::-;45540:18;;45467:38;;-1:-1:-1;45520:17:0;;45540:22;;45561:1;;45540:22;:::i;:::-;45520:42;;45596:13;45583:9;:26;45579:405;;45630:17;45650:3;:11;;45662:9;45650:22;;;;;;;;:::i;:::-;;;;;;;;;45630:42;;45804:9;45775:3;:11;;45787:13;45775:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;45889:23;;;:12;;;:23;;;;;:36;;;45579:405;46065:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;46160:3;:12;;:19;46173:5;46160:19;;;;;;;;;;;46153:26;;;46203:4;46196:11;;;;;;;45088:1176;46247:5;46240:12;;;;;64186:805;64253:16;;;64267:1;64253:16;;;;;;;;64226:24;;64253:16;;;;;;;;;;-1:-1:-1;64253:16:0;64226:43;;64301:4;64280:7;64288:1;64280:10;;;;;;;;:::i;:::-;;;;;;:26;-1:-1:-1;;;;;64280:26:0;;;-1:-1:-1;;;;;64280:26:0;;;;;64338:4;64317:7;64325:1;64317:10;;;;;;;;:::i;:::-;-1:-1:-1;;;;;64317:26:0;;;;:10;;;;;;;;;;:26;64396:4;64356:19;10133:18;;;;;;;;;;;;64428:15;64442:1;10133:18;64428:15;:::i;:::-;64413:30;;64464:4;64457;:11;64454:23;;;64470:7;;;64186:805::o;64454:23::-;64561:110;;-1:-1:-1;;;64561:110:0;;64515:21;;-1:-1:-1;;;;;64561:10:0;:61;;;;:110;;64623:4;;64489:23;;64632:7;;64649:4;;64655:15;;64561:110;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64557:427;;;64686:17;64706:39;64730:15;64706:21;:39;:::i;:::-;64766:100;;-1:-1:-1;;;64766:100:0;;64819:4;64766:100;;;20345:34:1;20395:18;;;20388:34;;;64832:1:0;20438:18:1;;;20431:34;;;20481:18;;;20474:34;;;20524:19;;;20517:44;64850:15:0;20577:19:1;;;20570:35;64686:59:0;;-1:-1:-1;;;;;;64766:10:0;:26;;;;64686:59;;20279:19:1;;64766:100:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64766:100:0;;;;;;;;-1:-1:-1;;64766:100:0;;;;;;;;;;;;:::i;:::-;;;64762:200;;;-1:-1:-1;;64891:46:0;;;21129:25:1;;;21185:2;21170:18;;21163:34;;;64921:15:0;21213:18:1;;;21206:34;;;;64891:46:0;;-1:-1:-1;21117:2:1;21102:18;64891:46:0;20927:319:1;64762:200:0;64671:304;64215:776;;;;64186:805::o;47705:111::-;47761:16;47797:3;:11;;47790:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47705:111;;;:::o;47035:120::-;47102:7;47129:3;:11;;47141:5;47129:18;;;;;;;;:::i;:::-;;;;;;;;;47122:25;;47035:120;;;;:::o;14:454:1:-;109:6;117;125;133;141;194:3;182:9;173:7;169:23;165:33;162:53;;;211:1;208;201:12;162:53;-1:-1:-1;;234:23:1;;;304:2;289:18;;276:32;;-1:-1:-1;355:2:1;340:18;;327:32;;406:2;391:18;;378:32;;-1:-1:-1;457:3:1;442:19;429:33;;-1:-1:-1;14:454:1;-1:-1:-1;14:454:1:o;473:250::-;558:1;568:113;582:6;579:1;576:13;568:113;;;658:11;;;652:18;639:11;;;632:39;604:2;597:10;568:113;;;-1:-1:-1;;715:1:1;697:16;;690:27;473:250::o;728:396::-;877:2;866:9;859:21;840:4;909:6;903:13;952:6;947:2;936:9;932:18;925:34;968:79;1040:6;1035:2;1024:9;1020:18;1015:2;1007:6;1003:15;968:79;:::i;:::-;1108:2;1087:15;-1:-1:-1;;1083:29:1;1068:45;;;;1115:2;1064:54;;728:396;-1:-1:-1;;728:396:1:o;1129:131::-;-1:-1:-1;;;;;1204:31:1;;1194:42;;1184:70;;1250:1;1247;1240:12;1265:315;1333:6;1341;1394:2;1382:9;1373:7;1369:23;1365:32;1362:52;;;1410:1;1407;1400:12;1362:52;1449:9;1436:23;1468:31;1493:5;1468:31;:::i;:::-;1518:5;1570:2;1555:18;;;;1542:32;;-1:-1:-1;;;1265:315:1:o;1985:160::-;2050:20;;2106:13;;2099:21;2089:32;;2079:60;;2135:1;2132;2125:12;2150:315;2215:6;2223;2276:2;2264:9;2255:7;2251:23;2247:32;2244:52;;;2292:1;2289;2282:12;2244:52;2331:9;2318:23;2350:31;2375:5;2350:31;:::i;:::-;2400:5;-1:-1:-1;2424:35:1;2455:2;2440:18;;2424:35;:::i;:::-;2414:45;;2150:315;;;;;:::o;2470:247::-;2529:6;2582:2;2570:9;2561:7;2557:23;2553:32;2550:52;;;2598:1;2595;2588:12;2550:52;2637:9;2624:23;2656:31;2681:5;2656:31;:::i;2904:456::-;2981:6;2989;2997;3050:2;3038:9;3029:7;3025:23;3021:32;3018:52;;;3066:1;3063;3056:12;3018:52;3105:9;3092:23;3124:31;3149:5;3124:31;:::i;:::-;3174:5;-1:-1:-1;3231:2:1;3216:18;;3203:32;3244:33;3203:32;3244:33;:::i;:::-;2904:456;;3296:7;;-1:-1:-1;;;3350:2:1;3335:18;;;;3322:32;;2904:456::o;3554:180::-;3613:6;3666:2;3654:9;3645:7;3641:23;3637:32;3634:52;;;3682:1;3679;3672:12;3634:52;-1:-1:-1;3705:23:1;;3554:180;-1:-1:-1;3554:180:1:o;4209:461::-;4262:3;4300:5;4294:12;4327:6;4322:3;4315:19;4353:4;4382:2;4377:3;4373:12;4366:19;;4419:2;4412:5;4408:14;4440:1;4450:195;4464:6;4461:1;4458:13;4450:195;;;4529:13;;-1:-1:-1;;;;;4525:39:1;4513:52;;4585:12;;;;4620:15;;;;4561:1;4479:9;4450:195;;;-1:-1:-1;4661:3:1;;4209:461;-1:-1:-1;;;;;4209:461:1:o;4675:261::-;4854:2;4843:9;4836:21;4817:4;4874:56;4926:2;4915:9;4911:18;4903:6;4874:56;:::i;5163:180::-;5219:6;5272:2;5260:9;5251:7;5247:23;5243:32;5240:52;;;5288:1;5285;5278:12;5240:52;5311:26;5327:9;5311:26;:::i;5583:529::-;5660:6;5668;5676;5729:2;5717:9;5708:7;5704:23;5700:32;5697:52;;;5745:1;5742;5735:12;5697:52;5784:9;5771:23;5803:31;5828:5;5803:31;:::i;:::-;5853:5;-1:-1:-1;5910:2:1;5895:18;;5882:32;5923:33;5882:32;5923:33;:::i;:::-;5975:7;-1:-1:-1;6034:2:1;6019:18;;6006:32;6047:33;6006:32;6047:33;:::i;:::-;6099:7;6089:17;;;5583:529;;;;;:::o;6117:388::-;6185:6;6193;6246:2;6234:9;6225:7;6221:23;6217:32;6214:52;;;6262:1;6259;6252:12;6214:52;6301:9;6288:23;6320:31;6345:5;6320:31;:::i;:::-;6370:5;-1:-1:-1;6427:2:1;6412:18;;6399:32;6440:33;6399:32;6440:33;:::i;:::-;6492:7;6482:17;;;6117:388;;;;;:::o;6510:127::-;6571:10;6566:3;6562:20;6559:1;6552:31;6602:4;6599:1;6592:15;6626:4;6623:1;6616:15;6642:340;6786:2;6771:18;;6819:1;6808:13;;6798:144;;6864:10;6859:3;6855:20;6852:1;6845:31;6899:4;6896:1;6889:15;6927:4;6924:1;6917:15;6798:144;6951:25;;;6642:340;:::o;6987:127::-;7048:10;7043:3;7039:20;7036:1;7029:31;7079:4;7076:1;7069:15;7103:4;7100:1;7093:15;7119:125;7184:9;;;7205:10;;;7202:36;;;7218:18;;:::i;8057:380::-;8136:1;8132:12;;;;8179;;;8200:61;;8254:4;8246:6;8242:17;8232:27;;8200:61;8307:2;8299:6;8296:14;8276:18;8273:38;8270:161;;8353:10;8348:3;8344:20;8341:1;8334:31;8388:4;8385:1;8378:15;8416:4;8413:1;8406:15;8270:161;;8057:380;;;:::o;8442:405::-;8644:2;8626:21;;;8683:2;8663:18;;;8656:30;8722:34;8717:2;8702:18;;8695:62;-1:-1:-1;;;8788:2:1;8773:18;;8766:39;8837:3;8822:19;;8442:405::o;8852:385::-;-1:-1:-1;;;;;9104:15:1;;;9086:34;;9156:15;;;;9151:2;9136:18;;9129:43;9215:14;;9208:22;9203:2;9188:18;;9181:50;9036:2;9021:18;;8852:385::o;9959:128::-;10026:9;;;10047:11;;;10044:37;;;10061:18;;:::i;10445:251::-;10515:6;10568:2;10556:9;10547:7;10543:23;10539:32;10536:52;;;10584:1;10581;10574:12;10536:52;10616:9;10610:16;10635:31;10660:5;10635:31;:::i;11454:184::-;11524:6;11577:2;11565:9;11556:7;11552:23;11548:32;11545:52;;;11593:1;11590;11583:12;11545:52;-1:-1:-1;11616:16:1;;11454:184;-1:-1:-1;11454:184:1:o;12421:287::-;12550:3;12588:6;12582:13;12604:66;12663:6;12658:3;12651:4;12643:6;12639:17;12604:66;:::i;:::-;12686:16;;;;;12421:287;-1:-1:-1;;12421:287:1:o;17001:168::-;17074:9;;;17105;;17122:15;;;17116:22;;17102:37;17092:71;;17143:18;;:::i;17174:217::-;17214:1;17240;17230:132;;17284:10;17279:3;17275:20;17272:1;17265:31;17319:4;17316:1;17309:15;17347:4;17344:1;17337:15;17230:132;-1:-1:-1;17376:9:1;;17174:217::o;19153:127::-;19214:10;19209:3;19205:20;19202:1;19195:31;19245:4;19242:1;19235:15;19269:4;19266:1;19259:15;19285:127;19346:10;19341:3;19337:20;19334:1;19327:31;19377:4;19374:1;19367:15;19401:4;19398:1;19391:15;19417:582;19716:6;19705:9;19698:25;19759:6;19754:2;19743:9;19739:18;19732:34;19802:3;19797:2;19786:9;19782:18;19775:31;19679:4;19823:57;19875:3;19864:9;19860:19;19852:6;19823:57;:::i;:::-;-1:-1:-1;;;;;19916:32:1;;;;19911:2;19896:18;;19889:60;-1:-1:-1;19980:3:1;19965:19;19958:35;19815:65;19417:582;-1:-1:-1;;;19417:582:1:o;20616:306::-;20704:6;20712;20720;20773:2;20761:9;20752:7;20748:23;20744:32;20741:52;;;20789:1;20786;20779:12;20741:52;20818:9;20812:16;20802:26;;20868:2;20857:9;20853:18;20847:25;20837:35;;20912:2;20901:9;20897:18;20891:25;20881:35;;20616:306;;;;;:::o

ipfs://cbe0c48066a2add099fb5ad0c9f95d94e7e3ba044f017cfaf1359b11a0d023a6