Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2023-05-01
*/

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

pragma solidity ^0.8.0;

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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }
}

// File: contracts/interfaces/ICamelotFactory.sol

pragma solidity >=0.5.0;

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

    function owner() external view returns (address);

    function feePercentOwner() external view returns (address);

    function setStableOwner() external view returns (address);

    function feeTo() external view returns (address);

    function ownerFeeShare() external view returns (uint256);

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

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

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

    function allPairsLength() external view returns (uint256);

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

    function setFeeTo(address) external;

    function feeInfo()
        external
        view
        returns (uint _ownerFeeShare, address _feeTo);
}

// File: contracts/interfaces/IUniswapV2Router01.sol

pragma solidity >=0.6.2;

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

    function WETH() external pure returns (address);

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

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

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

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

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

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

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

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

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

// File: contracts/interfaces/ICamelotRouter.sol

pragma solidity >=0.6.2;

interface ICamelotRouter is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);

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

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

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

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

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

// File: contracts/interfaces/IWETH.sol

pragma solidity >=0.5.0;

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

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

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

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

    function deposit() external payable;

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

    function withdraw(uint256) external;
}

interface ICamelotPair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint);

    function balanceOf(address owner) external view returns (uint);

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

    function approve(address spender, uint value) external returns (bool);

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

    function transferFrom(
        address from,
        address to,
        uint value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint);

    function permit(
        address owner,
        address spender,
        uint value,
        uint deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(
        address indexed sender,
        uint amount0,
        uint amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (
            uint112 reserve0,
            uint112 reserve1,
            uint16 token0feePercent,
            uint16 token1FeePercent
        );

    function getAmountOut(
        uint amountIn,
        address tokenIn
    ) external view returns (uint);

    function kLast() external view returns (uint);

    function setFeePercent(
        uint16 token0FeePercent,
        uint16 token1FeePercent
    ) external;

    function mint(address to) external returns (uint liquidity);

    function burn(address to) external returns (uint amount0, uint amount1);

    function swap(
        uint amount0Out,
        uint amount1Out,
        address to,
        bytes calldata data
    ) external;

    function swap(
        uint amount0Out,
        uint amount1Out,
        address to,
        bytes calldata data,
        address referrer
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

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

    event SwapBack(
        uint256 burn,
        uint256 gov1,
        uint256 gov2,
        uint256 liquidity,
        uint256 dev,
        bool isSuccess1,
        bool isSuccess2,
        uint timestamp
    );
    event Trade(
        address user,
        address pair,
        uint256 amount,
        uint side,
        bool isAdd,
        bool isDel,
        uint256 circulatingSupply,
        uint timestamp
    );
    event AddLiquidity(
        uint256 tokenAmount,
        uint256 ethAmount,
        uint256 timestamp
    );

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

    bool public isAddLiquidityFee = true;

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

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

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

    // Buy Fees
    uint256 public burnFeeBuy = 100;
    uint256 public gov1FeeBuy = 750;
    uint256 public gov2FeeBuy = 50;
    uint256 public liquidityFeeBuy = 300;
    uint256 public devFeeBuy = 300;
    uint256 public totalFeeBuy = 1500;
    // Sell Fees
    uint256 public burnFeeSell = 100;
    uint256 public gov1FeeSell = 750;
    uint256 public gov2FeeSell = 50;
    uint256 public liquidityFeeSell = 300;
    uint256 public devFeeSell = 300;
    uint256 public totalFeeSell = 1500;

    //  liquidity
    uint256 public burnFeeLiquidity = 200;
    uint256 public gov1FeeLiquidity = 1500;
    uint256 public gov2FeeLiquidity = 100;
    uint256 public liquidityFeeLiquidity = 600;
    uint256 public devFeeLiquidity = 600;
    uint256 public totalFeeLiquidity = 3000;

    uint256 public removeLiquidityFee = 3000;

    // Fees receivers
    address private gov1Wallet;
    address private gov2Wallet;
    address private devWallet;

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

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

    EnumerableSet.AddressSet private _pairs;

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

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

    function _isLiquidity(
        address from,
        address to,
        address pair
    ) internal view returns (bool isAdd, bool isDel) {
        if (pair == address(0)) return (false, false);
        address token0 = ICamelotPair(address(pair)).token0();
        address token1 = ICamelotPair(address(pair)).token1();
        (uint112 r0, uint112 r1, , ) = ICamelotPair(address(pair))
            .getReserves();
        address otherToken;
        uint112 otherTokenReserve;
        if (token0 == address(this)) {
            otherToken = token1;
            otherTokenReserve = r1;
        } else {
            otherToken = token0;
            otherTokenReserve = r0;
        }
        uint256 bal0 = IERC20(otherToken).balanceOf(address(pair));
        if (isPair(to)) {
            if (bal0 > otherTokenReserve) {
                isAdd = true;
            }
        }
        if (isPair(from)) {
            if (bal0 < otherTokenReserve) {
                isDel = true;
            }
        }
    }

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

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

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

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

        bool shouldTakeFee = (!isFeeExempt[sender] &&
            !isFeeExempt[recipient]) && launched();
        uint side = 0;
        address user_ = sender;
        address pair_ = recipient;

        // Set Fees
        if (isPair(sender)) {
            buyFees();
            side = 1;
            user_ = recipient;
            pair_ = sender;
        } else if (isPair(recipient)) {
            sellFees();
            side = 2;
        } else {
            sellFees();
            side = 3;
        }
        bool isAdd;
        bool isDel;
        if (isAddLiquidityFee && isPair(pair_)) {
            (isAdd, isDel) = _isLiquidity(sender, recipient, pair_);

            if (isAdd) {
                liquidityFees();
                side = 4;
            }
            if (isDel) {
                shouldTakeFee = false;
                side = 5;
            }
        }

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

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

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

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

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

        uint256 amountDogBurn = (taxAmount * burnFee) / (totalFee);
        uint256 amountDogLp = (taxAmount * liquidityFee) / (totalFee);
        uint256 amountDogReward = (taxAmount * gov2FeeBuy) / (totalFee);
        taxAmount -= amountDogBurn;
        taxAmount -= amountDogLp;
        taxAmount -= amountDogReward;

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

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

        _transfer(address(this), DEAD, amountDogBurn);
        _transfer(address(this), gov2Wallet, amountDogReward);
        uint256 amountBackToken = address(this).balance - balanceBefore;
        uint256 backTokenTotalFee = totalFee - burnFee - liquidityFee - gov2Fee;
        uint256 amountBackTokenGov1 = (amountBackToken * gov1Fee) /
            (backTokenTotalFee);
        uint256 amountBackTokenDev = amountBackToken - amountBackTokenGov1;
        (bool isSuccess1, ) = payable(gov1Wallet).call{
            value: amountBackTokenGov1
        }(new bytes(0));
        (bool isSuccess2, ) = payable(devWallet).call{
            value: amountBackTokenDev
        }(new bytes(0));

        if (addLiquidityEnabled) {
            _doAddLp();
        }

        emit SwapBack(
            amountDogBurn,
            amountBackTokenGov1,
            amountDogReward,
            amountDogLp,
            amountBackTokenDev,
            isSuccess1,
            isSuccess2,
            block.timestamp
        );
    }

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

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

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

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

    function removeLiquid(uint256 amount, address pair) external {
        require(amount > 0, "Invalid amount");
        if (isFeeExempt[msg.sender]) {
            IERC20(address(pair)).safeTransferFrom(
                msg.sender,
                address(pair),
                amount
            );
            ICamelotPair(pair).burn(msg.sender);
            return;
        }
        uint256 transferAmount = (amount * removeLiquidityFee) / feeDenominator;

        IERC20(address(pair)).safeTransferFrom(
            msg.sender,
            address(devWallet),
            transferAmount
        );

        IERC20(address(pair)).safeTransferFrom(
            msg.sender,
            address(pair),
            amount - transferAmount
        );
        ICamelotPair LPToken = ICamelotPair(pair);
        LPToken.burn(msg.sender);
    }

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

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

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

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

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

    function liquidityFees() internal {
        burnFee = burnFeeLiquidity;
        gov1Fee = gov1FeeLiquidity;
        gov2Fee = gov2FeeLiquidity;
        liquidityFee = liquidityFeeLiquidity;
        devFee = devFeeLiquidity;
        totalFee = totalFeeLiquidity;
    }

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

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

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

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

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

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

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

    function setLiquidityFees(
        uint256 _gov1Fee,
        uint256 _gov2Fee,
        uint256 _liquidityFee,
        uint256 _devFee,
        uint256 _burnFee,
        uint256 _removeLiquidityFee
    ) external onlyOwner {
        gov1FeeLiquidity = _gov1Fee;
        gov2FeeLiquidity = _gov2Fee;
        liquidityFeeLiquidity = _liquidityFee;
        devFeeLiquidity = _devFee;
        burnFeeLiquidity = _burnFee;
        removeLiquidityFee = _removeLiquidityFee;
        totalFeeLiquidity =
            _gov1Fee +
            _gov2Fee +
            _liquidityFee +
            _devFee +
            _burnFee;
    }

    function setFeeReceivers(
        address _gov1Wallet,
        address _gov2Wallet,
        address _devWallet
    ) external onlyOwner {
        gov1Wallet = _gov1Wallet;
        gov2Wallet = _gov2Wallet;
        devWallet = _devWallet;
    }

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

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

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

    function setIsAddLiquidityFee(bool value) external onlyOwner {
        isAddLiquidityFee = value;
    }

    function getLPAmount(
        address account,
        address _pair
    ) public view returns (uint256) {
        return ICamelotPair(address(_pair)).balanceOf(account);
    }

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

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

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

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

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

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_swapRouter","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AddLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"burn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gov1","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gov2","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"liquidity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dev","type":"uint256"},{"indexed":false,"internalType":"bool","name":"isSuccess1","type":"bool"},{"indexed":false,"internalType":"bool","name":"isSuccess2","type":"bool"},{"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":"bool","name":"isAdd","type":"bool"},{"indexed":false,"internalType":"bool","name":"isDel","type":"bool"},{"indexed":false,"internalType":"uint256","name":"circulatingSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Trade","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"addLiquidityEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"addPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnFeeLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"canAddLiquidityBeforeLaunch","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clearStuckEthBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"delPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devFeeLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"doSwapBack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCirculatingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"_pair","type":"address"}],"name":"getLPAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinterLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov1Fee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov1FeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov1FeeLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov1FeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov2Fee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov2FeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov2FeeLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gov2FeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inSwap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initializePair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isAddLiquidityFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"launchedAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launchedAtTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFeeLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"pair","type":"address"}],"name":"removeLiquid","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"removeLiquidityFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"rescueToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setAddLiquidityEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gov1Fee","type":"uint256"},{"internalType":"uint256","name":"_gov2Fee","type":"uint256"},{"internalType":"uint256","name":"_liquidityFee","type":"uint256"},{"internalType":"uint256","name":"_devFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"}],"name":"setBuyFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_gov1Wallet","type":"address"},{"internalType":"address","name":"_gov2Wallet","type":"address"},{"internalType":"address","name":"_devWallet","type":"address"}],"name":"setFeeReceivers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setIsAddLiquidityFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gov1Fee","type":"uint256"},{"internalType":"uint256","name":"_gov2Fee","type":"uint256"},{"internalType":"uint256","name":"_liquidityFee","type":"uint256"},{"internalType":"uint256","name":"_devFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"},{"internalType":"uint256","name":"_removeLiquidityFee","type":"uint256"}],"name":"setLiquidityFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gov1Fee","type":"uint256"},{"internalType":"uint256","name":"_gov2Fee","type":"uint256"},{"internalType":"uint256","name":"_liquidityFee","type":"uint256"},{"internalType":"uint256","name":"_devFee","type":"uint256"},{"internalType":"uint256","name":"_burnFee","type":"uint256"}],"name":"setSellFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setSwapBackSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000006eccab422d763ac031210895c81787e87b43a652000000000000000000000000c873fecbd354f5a56e00e710b90ef4201db2448d00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1

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

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

61519:17869:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75892:182;;;;;;;;;;;;;:::i;:::-;;62643:22;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;62643:22:0;;;;;;;;79057:98;;;;;;;;;;;;;:::i;6863:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;9280:226::-;;;;;;;;;;-1:-1:-1;9280:226:0;;;;;:::i;:::-;;:::i;:::-;;;1473:14:1;;1466:22;1448:41;;1436:2;1421:18;9280:226:0;1308:187:1;63197:37:0;;;;;;;;;;;;;;;;63241:31;;;;;;;;;;;;;;;;62830;;;;;;;;;;;;;;;;62767:37;;;;;;;;;;;;;;;;7983:108;;;;;;;;;;-1:-1:-1;8071:12:0;;7983:108;;63081:32;;;;;;;;;;;;;;;;66394:303;;;;;;;;;;-1:-1:-1;66394:303:0;;;;;:::i;:::-;;:::i;75716:137::-;;;;;;;;;;;;;:::i;66112:92::-;;;;;;;;;;-1:-1:-1;66112:92:0;;66195:1;2103:36:1;;2091:2;2076:18;66112:92:0;1961:184:1;10790:263:0;;;;;;;;;;-1:-1:-1;10790:263:0;;;;;:::i;:::-;;:::i;62466:43::-;;;;;;;;;;-1:-1:-1;62466:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;75207:210;;;;;;;;;;-1:-1:-1;75207:210:0;;;;;:::i;:::-;;:::i;76082:442::-;;;;;;;;;;-1:-1:-1;76082:442:0;;;;;:::i;:::-;;:::i;62299:36::-;;;;;;;;;;-1:-1:-1;62299:36:0;;;;-1:-1:-1;;;62299:36:0;;;;;;64821:238;;;;;;;;;;;;;:::i;63279:34::-;;;;;;;;;;;;;;;;78256:105;;;;;;;;;;-1:-1:-1;78256:105:0;;;;;:::i;:::-;;:::i;77894:119::-;;;;;;;;;;-1:-1:-1;77894:119:0;;;;;:::i;:::-;;:::i;62215:30::-;;;;;;;;;;-1:-1:-1;62215:30:0;;;;-1:-1:-1;;;62215:30:0;;;;;;8154:143;;;;;;;;;;-1:-1:-1;8154:143:0;;;;;:::i;:::-;-1:-1:-1;;;;;8271:18:0;8244:7;8271:18;;;;;;;;;;;;8154:143;62868:31;;;;;;;;;;;;;;;;37860:103;;;;;;;;;;;;;:::i;62516:59::-;;;;;;;;;;-1:-1:-1;62516:59:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;62943:36;;;;;;;;;;;;;;;;63566:39;;;;;;;;;;;;;;;;62252:38;;;;;;;;;;-1:-1:-1;62252:38:0;;;;-1:-1:-1;;;62252:38:0;;;;;;72599:864;;;;;;;;;;-1:-1:-1;72599:864:0;;;;;:::i;:::-;;:::i;37212:87::-;;;;;;;;;;-1:-1:-1;37285:6:0;;-1:-1:-1;;;;;37285:6:0;37212:87;;;-1:-1:-1;;;;;4101:32:1;;;4083:51;;4071:2;4056:18;37212:87:0;3937:203:1;73990:68:0;;;;;;;;;;;;;:::i;7082:104::-;;;;;;;;;;;;;:::i;11556:498::-;;;;;;;;;;-1:-1:-1;11556:498:0;;;;;:::i;:::-;;:::i;78865:184::-;;;;;;;;;;-1:-1:-1;78865:184:0;;;;;:::i;:::-;;:::i;63523:36::-;;;;;;;;;;;;;;;;66212:174;;;;;;;;;;-1:-1:-1;66212:174:0;;;;;:::i;:::-;;:::i;78133:115::-;;;;;;;;;;-1:-1:-1;78133:115:0;;;;;:::i;:::-;;:::i;63474:42::-;;;;;;;;;;;;;;;;63159:31;;;;;;;;;;;;;;;;63385:38;;;;;;;;;;;;;;;;78021:104;;;;;;;;;;-1:-1:-1;78021:104:0;;;;;:::i;:::-;;:::i;79163:185::-;;;;;;;;;;-1:-1:-1;79163:185:0;;;;;:::i;:::-;;:::i;63786:25::-;;;;;;;;;;;;;;;;75425:283;;;;;;;;;;;;;:::i;63614:40::-;;;;;;;;;;;;;;;;76989:638;;;;;;;;;;-1:-1:-1;76989:638:0;;;;;:::i;:::-;;:::i;63341:37::-;;;;;;;;;;;;;;;;76532:449;;;;;;;;;;-1:-1:-1;76532:449:0;;;;;:::i;:::-;;:::i;78676:181::-;;;;;;;;;;-1:-1:-1;78676:181:0;;;;;:::i;:::-;;:::i;78369:::-;;;;;;;;;;-1:-1:-1;78369:181:0;;;;;:::i;:::-;;:::i;63818:34::-;;;;;;;;;;;;;;;;62614:22;;;;;;;;;;;;;;;;62986:30;;;;;;;;;;;;;;;;77635:251;;;;;;;;;;-1:-1:-1;77635:251:0;;;;;:::i;:::-;;:::i;62344:18::-;;;;;;;;;;-1:-1:-1;62344:18:0;;;;-1:-1:-1;;;62344:18:0;;;;;;63120:32;;;;;;;;;;;;;;;;8784:176;;;;;;;;;;-1:-1:-1;8784:176:0;;;;;:::i;:::-;;:::i;62906:30::-;;;;;;;;;;;;;;;;78558:110;;;;;;;;;;-1:-1:-1;78558:110:0;;;;;:::i;:::-;;:::i;38118:238::-;;;;;;;;;;-1:-1:-1;38118:238:0;;;;;:::i;:::-;;:::i;63023:33::-;;;;;;;;;;;;;;;;63430:37;;;;;;;;;;;;;;;;75892:182;37098:13;:11;:13::i;:::-;75946:10:::1;::::0;:15;75938:44:::1;;;::::0;-1:-1:-1;;;75938:44:0;;5987:2:1;75938:44:0::1;::::0;::::1;5969:21:1::0;6026:2;6006:18;;;5999:30;-1:-1:-1;;;6045:18:1;;;6038:46;6101:18;;75938:44:0::1;;;;;;;;;76006:12;75993:10;:25:::0;76051:15:::1;76029:19;:37:::0;75892:182::o;79057:98::-;79105:7;79132:15;:6;:13;:15::i;:::-;79125:22;;79057:98;:::o;6863:100::-;6917:13;6950:5;6943:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6863:100;:::o;9280:226::-;9388:4;4593:10;9444:32;4593:10;9460:7;9469:6;9444:8;:32::i;:::-;9494:4;9487:11;;;9280:226;;;;;:::o;66394:303::-;66534:4;4593:10;66592:40;66608:6;4593:10;66625:6;66592:15;:40::i;:::-;66650:39;66663:6;66671:9;66682:6;66650:12;:39::i;:::-;66643:46;;;66394:303;;;;;;:::o;75716:137::-;75769:7;8271:18;;;;;;64057:42;8271:18;;;;8071:12;;75796:31;;8271:18;75796:31;:::i;:::-;:49;;;;:::i;10790:263::-;10903:4;4593:10;10959:64;4593:10;10975:7;11012:10;10984:25;4593:10;10975:7;10984:9;:25::i;:::-;:38;;;;:::i;:::-;10959:8;:64::i;75207:210::-;37098:13;:11;:13::i;:::-;75353:45:::1;::::0;-1:-1:-1;;;75353:45:0;;75392:4:::1;75353:45;::::0;::::1;4083:51:1::0;75280:129:0::1;::::0;75328:10:::1;::::0;-1:-1:-1;;;;;75353:30:0;::::1;::::0;::::1;::::0;4056:18:1;;75353:45:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;75280:33:0;::::1;::::0;:129;:33:::1;:129::i;:::-;75207:210:::0;:::o;76082:442::-;37098:13;:11;:13::i;:::-;76278:10:::1;:21:::0;;;76310:10:::1;:21:::0;;;76342:15:::1;:31:::0;;;76384:9:::1;:19:::0;;;76414:10:::1;:21:::0;;;76427:8;76396:7;76360:13;76460:19:::1;76323:8:::0;76291;76460:19:::1;:::i;:::-;:35;;;;:::i;:::-;:45;;;;:::i;:::-;:56;;;;:::i;:::-;76446:11;:70:::0;-1:-1:-1;;;;;76082:442:0:o;64821:238::-;37098:13;:11;:13::i;:::-;64886:11:::1;::::0;::::1;;64885:12;64877:44;;;::::0;-1:-1:-1;;;64877:44:0;;7301:2:1;64877:44:0::1;::::0;::::1;7283:21:1::0;7340:2;7320:18;;;7313:30;-1:-1:-1;;;7359:18:1;;;7352:49;7418:18;;64877:44:0::1;7099:343:1::0;64877:44:0::1;64947:48;::::0;-1:-1:-1;;;64947:48:0;;-1:-1:-1;;;;;64974:4:0::1;7677:15:1::0;;64947:48:0::1;::::0;::::1;7659:34:1::0;64989:4:0::1;7709:18:1::0;;;7702:43;-1:-1:-1;;64947:7:0::1;:18:::0;;::::1;::::0;::::1;::::0;7594::1;;64947:48:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64932:63:::0;-1:-1:-1;65006:16:0::1;:6;64932:63:::0;65006:10:::1;:16::i;:::-;-1:-1:-1::0;;65033:11:0::1;:18:::0;;-1:-1:-1;;65033:18:0::1;65047:4;65033:18;::::0;;64821:238::o;78256:105::-;37098:13;:11;:13::i;:::-;78328:17:::1;:25:::0;;;::::1;;-1:-1:-1::0;;;78328:25:0::1;-1:-1:-1::0;;;;78328:25:0;;::::1;::::0;;;::::1;::::0;;78256:105::o;77894:119::-;37098:13;:11;:13::i;:::-;-1:-1:-1;;;;;77977:19:0;;;::::1;;::::0;;;:11:::1;:19;::::0;;;;:28;;-1:-1:-1;;77977:28:0::1;::::0;::::1;;::::0;;;::::1;::::0;;77894:119::o;37860:103::-;37098:13;:11;:13::i;:::-;37925:30:::1;37952:1;37925:18;:30::i;:::-;37860:103::o:0;72599:864::-;72688:1;72679:6;:10;72671:37;;;;-1:-1:-1;;;72671:37:0;;8214:2:1;72671:37:0;;;8196:21:1;8253:2;8233:18;;;8226:30;-1:-1:-1;;;8272:18:1;;;8265:44;8326:18;;72671:37:0;8012:338:1;72671:37:0;72735:10;72723:23;;;;:11;:23;;;;;;;;72719:266;;;72763:139;-1:-1:-1;;;;;72763:38:0;;72820:10;72857:4;72881:6;72763:38;:139::i;:::-;72917:35;;-1:-1:-1;;;72917:35:0;;72941:10;72917:35;;;4083:51:1;-1:-1:-1;;;;;72917:23:0;;;;;4056:18:1;;72917:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;72599:864;;:::o;72719:266::-;72995:22;73052:14;;73030:18;;73021:6;:27;;;;:::i;:::-;73020:46;;;;:::i;:::-;73165:9;;72995:71;;-1:-1:-1;73079:136:0;;-1:-1:-1;;;;;73079:38:0;;;;73132:10;;73165:9;72995:71;73079:38;:136::i;:::-;73228:140;73281:10;73314:4;73334:23;73343:14;73334:6;:23;:::i;:::-;-1:-1:-1;;;;;73228:38:0;;;:140;;:38;:140::i;:::-;73431:24;;-1:-1:-1;;;73431:24:0;;73444:10;73431:24;;;4083:51:1;73415:4:0;;-1:-1:-1;;;;;73431:12:0;;;;;4056:18:1;;73431:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;72660:803;;72599:864;;:::o;73990:68::-;37098:13;:11;:13::i;:::-;74040:10:::1;:8;:10::i;7082:104::-:0;7138:13;7171:7;7164:14;;;;;:::i;11556:498::-;11674:4;4593:10;11674:4;11757:25;4593:10;11774:7;11757:9;:25::i;:::-;11730:52;;11835:15;11815:16;:35;;11793:122;;;;-1:-1:-1;;;11793:122:0;;9202:2:1;11793:122:0;;;9184:21:1;9241:2;9221:18;;;9214:30;9280:34;9260:18;;;9253:62;-1:-1:-1;;;9331:18:1;;;9324:35;9376:19;;11793:122:0;9000:401:1;11793:122:0;11951:60;11960:5;11967:7;11995:15;11976:16;:34;11951:8;:60::i;:::-;-1:-1:-1;12042:4:0;;11556:498;-1:-1:-1;;;;11556:498:0:o;78865:184::-;78922:4;37098:13;:11;:13::i;:::-;-1:-1:-1;;;;;78947:18:0;::::1;78939:65;;;;-1:-1:-1::0;;;78939:65:0::1;;;;;;;:::i;:::-;79022:19;:6;79036:4:::0;79022:13:::1;:19::i;:::-;79015:26;;37122:1;78865:184:::0;;;:::o;66212:174::-;66316:4;66340:38;4593:10;66367:2;66371:6;66340:12;:38::i;78133:115::-;37098:13;:11;:13::i;:::-;78210:19:::1;:30:::0;;;::::1;;-1:-1:-1::0;;;78210:30:0::1;-1:-1:-1::0;;;;78210:30:0;;::::1;::::0;;;::::1;::::0;;78133:115::o;78021:104::-;37098:13;:11;:13::i;:::-;78095:11:::1;:22:::0;;;::::1;;-1:-1:-1::0;;;78095:22:0::1;-1:-1:-1::0;;;;78095:22:0;;::::1;::::0;;;::::1;::::0;;78021:104::o;79163:185::-;79216:7;79271:1;79253:15;:6;:13;:15::i;:::-;:19;;;;:::i;:::-;79244:5;:28;;79236:70;;;;-1:-1:-1;;;79236:70:0;;10011:2:1;79236:70:0;;;9993:21:1;10050:2;10030:18;;;10023:30;10089:31;10069:18;;;10062:59;10138:18;;79236:70:0;9809:353:1;79236:70:0;79324:16;:6;79334:5;79324:9;:16::i;75425:283::-;37098:13;:11;:13::i;:::-;75617:12:::1;::::0;;75487:17:::1;75617:12:::0;;;::::1;::::0;::::1;::::0;;;;75507:21:::1;::::0;75487:17;;4593:10;;75507:21;;75558:82:::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75539:101;;;75659:7;75651:49;;;::::0;-1:-1:-1;;;75651:49:0;;10793:2:1;75651:49:0::1;::::0;::::1;10775:21:1::0;10832:2;10812:18;;;10805:30;10871:31;10851:18;;;10844:59;10920:18;;75651:49:0::1;10591:353:1::0;75651:49:0::1;75476:232;;75425:283::o:0;76989:638::-;37098:13;:11;:13::i;:::-;77229:16:::1;:27:::0;;;77267:16:::1;:27:::0;;;77305:21:::1;:37:::0;;;77353:15:::1;:25:::0;;;77389:16:::1;:27:::0;;;77427:18:::1;:40:::0;;;77408:8;77371:7;77329:13;77511:32:::1;77286:8:::0;77248;77511:32:::1;:::i;:::-;:61;;;;:::i;:::-;:84;;;;:::i;:::-;:108;;;;:::i;:::-;77478:17;:141:::0;-1:-1:-1;;;;;;76989:638:0:o;76532:449::-;37098:13;:11;:13::i;:::-;76729:11:::1;:22:::0;;;76762:11:::1;:22:::0;;;76795:16:::1;:32:::0;;;76838:10:::1;:20:::0;;;76869:11:::1;:22:::0;;;76883:8;76851:7;76814:13;76917:19:::1;76776:8:::0;76743;76917:19:::1;:::i;:::-;:35;;;;:::i;:::-;:45;;;;:::i;:::-;:56;;;;:::i;:::-;76902:12;:71:::0;-1:-1:-1;;;;;76532:449:0:o;78676:181::-;78733:4;37098:13;:11;:13::i;:::-;-1:-1:-1;;;;;78758:18:0;::::1;78750:65;;;;-1:-1:-1::0;;;78750:65:0::1;;;;;;;:::i;:::-;78833:16;:6;78844:4:::0;78833:10:::1;:16::i;78369:181::-:0;78495:47;;-1:-1:-1;;;78495:47:0;;-1:-1:-1;;;;;4101:32:1;;;78495:47:0;;;4083:51:1;78468:7:0;;78495:38;;;;;;4056:18:1;;78495:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;77635:251::-;37098:13;:11;:13::i;:::-;77786:10:::1;:24:::0;;-1:-1:-1;;;;;77786:24:0;;::::1;-1:-1:-1::0;;;;;;77786:24:0;;::::1;;::::0;;;77821:10:::1;:24:::0;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;77856:9:::1;:22:::0;;;;;::::1;::::0;::::1;;::::0;;77635:251::o;8784:176::-;-1:-1:-1;;;;;8925:18:0;;;8898:7;8925:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8784:176::o;78558:110::-;78612:4;78636:24;:6;78652:7;78636:15;:24::i;38118:238::-;37098:13;:11;:13::i;:::-;-1:-1:-1;;;;;38221:22:0;::::1;38199:110;;;::::0;-1:-1:-1;;;38199:110:0;;11151:2:1;38199:110:0::1;::::0;::::1;11133:21:1::0;11190:2;11170:18;;;11163:30;11229:34;11209:18;;;11202:62;-1:-1:-1;;;11280:18:1;;;11273:36;11326:19;;38199:110:0::1;10949:402:1::0;38199:110:0::1;38320:28;38339:8;38320:18;:28::i;37377:132::-:0;37285:6;;-1:-1:-1;;;;;37285:6:0;4593:10;37441:23;37433:68;;;;-1:-1:-1;;;37433:68:0;;11558:2:1;37433:68:0;;;11540:21:1;;;11577:18;;;11570:30;11636:34;11616:18;;;11609:62;11688:18;;37433:68:0;11356:356:1;48354:117:0;48417:7;48444:19;48452:3;43438:18;;43355:109;15682:380;-1:-1:-1;;;;;15818:19:0;;15810:68;;;;-1:-1:-1;;;15810:68:0;;11919:2:1;15810:68:0;;;11901:21:1;11958:2;11938:18;;;11931:30;11997:34;11977:18;;;11970:62;-1:-1:-1;;;12048:18:1;;;12041:34;12092:19;;15810:68:0;11717:400:1;15810:68:0;-1:-1:-1;;;;;15897:21:0;;15889:68;;;;-1:-1:-1;;;15889:68:0;;12324:2:1;15889:68:0;;;12306:21:1;12363:2;12343:18;;;12336:30;12402:34;12382:18;;;12375:62;-1:-1:-1;;;12453:18:1;;;12446:32;12495:19;;15889:68:0;12122:398:1;15889:68:0;-1:-1:-1;;;;;15970:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;16022:32;;160:25:1;;;16022:32:0;;133:18:1;16022:32:0;;;;;;;15682:380;;;:::o;16353:502::-;16488:24;16515:25;16525:5;16532:7;16515:9;:25::i;:::-;16488:52;;-1:-1:-1;;16555:16:0;:37;16551:297;;16655:6;16635:16;:26;;16609:117;;;;-1:-1:-1;;;16609:117:0;;12727:2:1;16609:117:0;;;12709:21:1;12766:2;12746:18;;;12739:30;12805:31;12785:18;;;12778:59;12854:18;;16609:117:0;12525:353:1;16609:117:0;16770:51;16779:5;16786:7;16814:6;16795:16;:25;16770:8;:51::i;66705:1895::-;66851:6;;66830:4;;-1:-1:-1;;;66851:6:0;;;;66847:101;;;66874:36;66884:6;66892:9;66903:6;66874:9;:36::i;:::-;-1:-1:-1;66932:4:0;66925:11;;66847:101;-1:-1:-1;;;;;66963:35:0;;;;;;:27;:35;;;;;;;;66958:161;;74133:10;;:15;;67023:33;;;-1:-1:-1;;;;;;67037:19:0;;;;;;:11;:19;;;;;;;;67023:33;:59;;;-1:-1:-1;;;;;;67060:22:0;;;;;;:11;:22;;;;;;;;67023:59;67015:92;;;;-1:-1:-1;;;67015:92:0;;13085:2:1;67015:92:0;;;13067:21:1;13124:2;13104:18;;;13097:30;-1:-1:-1;;;13143:18:1;;;13136:50;13203:18;;67015:92:0;12883:344:1;67015:92:0;-1:-1:-1;;;;;67154:19:0;;67131:18;67154:19;;;:11;:19;;;;;;;;67153:20;:60;;;;-1:-1:-1;;;;;;67191:22:0;;;;;;:11;:22;;;;;;;;67190:23;67153:60;67152:76;;;;-1:-1:-1;74133:10:0;;:15;;67218:10;67131:97;-1:-1:-1;67239:9:0;67279:6;67312:9;67359:14;67279:6;67359;:14::i;:::-;67355:295;;;67390:9;74213:10;;74203:7;:20;74244:10;;74234:7;:20;74275:10;;74265:7;:20;74311:15;;74296:12;:30;74346:9;;74337:6;:18;74377:11;;74366:8;:22;74164:232;67390:9;-1:-1:-1;67421:1:0;;-1:-1:-1;67445:9:0;;-1:-1:-1;67477:6:0;67355:295;;;67505:17;67512:9;67505:6;:17::i;:::-;67501:149;;;67539:10;74454:11;;74444:7;:21;74486:11;;74476:7;:21;74518:11;;74508:7;:21;74555:16;;-1:-1:-1;74540:31:0;74591:10;;-1:-1:-1;74582:19:0;74623:12;;-1:-1:-1;74612:23:0;74404:239;67539:10;67571:1;67564:8;;67501:149;;;67605:10;74454:11;;74444:7;:21;74486:11;;74476:7;:21;74518:11;;74508:7;:21;74555:16;;-1:-1:-1;74540:31:0;74591:10;;-1:-1:-1;74582:19:0;74623:12;;-1:-1:-1;74612:23:0;74404:239;67605:10;67637:1;67630:8;;67501:149;67706:17;;67660:10;;;;-1:-1:-1;;;67706:17:0;;;;:34;;;;;67727:13;67734:5;67727:6;:13::i;:::-;67702:334;;;67774:38;67787:6;67795:9;67806:5;67774:12;:38::i;:::-;67757:55;;-1:-1:-1;67757:55:0;-1:-1:-1;67829:88:0;;;;67859:15;74706:16;;74696:7;:26;74743:16;;74733:7;:26;74780:16;;74770:7;:26;74822:21;;74807:12;:36;74863:15;;74854:6;:24;74900:17;;74889:8;:28;74651:274;67859:15;67900:1;67893:8;;67829:88;67935:5;67931:94;;;67977:5;67961:21;;68008:1;68001:8;;67931:94;68052:16;:14;:16::i;:::-;68048:59;;;68085:10;:8;:10::i;:::-;68119:22;68144:13;:74;;68212:6;68144:74;;;68173:23;68181:6;68189;68173:7;:23::i;:::-;68119:99;;68229:44;68239:6;68247:9;68258:14;68229:9;:44::i;:::-;68290:8;;68286:285;;68320:239;68344:5;68368;68392:6;68417:4;68440:5;68464;68488:22;:20;:22::i;:::-;68320:239;;;-1:-1:-1;;;;;13619:15:1;;;13601:34;;13671:15;;;;13666:2;13651:18;;13644:43;13703:18;;;13696:34;;;;13761:2;13746:18;;13739:34;;;;13817:14;13810:22;13804:3;13789:19;;13782:51;13877:14;13870:22;13581:3;13849:19;;13842:51;13924:3;13909:19;;13902:35;68529:15:0;13968:3:1;13953:19;;13946:35;13550:3;13535:19;68320:239:0;;;;;;;68286:285;-1:-1:-1;68588:4:0;;66705:1895;-1:-1:-1;;;;;;;;;;66705:1895:0:o;31683:214::-;31820:58;;-1:-1:-1;;;;;14184:32:1;;31820:58:0;;;14166:51:1;14233:18;;;14226:34;;;31766:123:0;;31800:5;;-1:-1:-1;;;31843:23:0;14139:18:1;;31820:58:0;;;;-1:-1:-1;;31820:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;31820:58:0;-1:-1:-1;;;;;;31820:58:0;;;;;;;;;;31766:19;:123::i;:::-;31683:214;;;:::o;47454:177::-;47549:4;47573:50;47578:3;-1:-1:-1;;;;;47598:23:0;;47573:4;:50::i;38516:191::-;38609:6;;;-1:-1:-1;;;;;38626:17:0;;;-1:-1:-1;;;;;;38626:17:0;;;;;;;38659:40;;38609:6;;;38626:17;38609:6;;38659:40;;38590:16;;38659:40;38579:128;38516:191;:::o;31905:285::-;32103:68;;-1:-1:-1;;;;;14529:15:1;;;32103:68:0;;;14511:34:1;14581:15;;14561:18;;;14554:43;14613:18;;;14606:34;;;32049:133:0;;32083:5;;-1:-1:-1;;;32126:27:0;14446:18:1;;32103:68:0;14271:375:1;68855:2489:0;62400:6;:13;;-1:-1:-1;;;;62400:13:0;-1:-1:-1;;;62400:13:0;;;68942:4:::1;-1:-1:-1::0;8271:18:0;;;;;;;;;;;68904:44:::1;;68959:55;68976:4;68991:10;69004:9;68959:8;:55::i;:::-;69027:21;69076:8;;69064:7;;69052:9;:19;;;;:::i;:::-;69051:34;;;;:::i;:::-;69027:58;;69096:19;69148:8;;69131:12;;69119:9;:24;;;;:::i;:::-;69118:39;;;;:::i;:::-;69096:61;;69168:23;69222:8;;69207:10;;69195:9;:22;;;;:::i;:::-;69194:37;;;;:::i;:::-;69168:63:::0;-1:-1:-1;69242:26:0::1;69255:13:::0;69242:26;::::1;:::i;:::-;::::0;-1:-1:-1;69279:24:0::1;69292:11:::0;69242:26;69279:24:::1;:::i;:::-;::::0;-1:-1:-1;69314:28:0::1;69327:15:::0;69279:24;69314:28:::1;:::i;:::-;69379:16;::::0;;69393:1:::1;69379:16:::0;;;;;::::1;::::0;;69314:28;;-1:-1:-1;69355:21:0::1;::::0;69379:16;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;69379:16:0::1;69355:40;;69424:4;69406;69411:1;69406:7;;;;;;;;:::i;:::-;;;;;;:23;-1:-1:-1::0;;;;;69406:23:0::1;;;-1:-1:-1::0;;;;;69406:23:0::1;;;::::0;::::1;69458:4;69440;69445:1;69440:7;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;69440:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;69580:242:::1;::::0;-1:-1:-1;;;69580:242:0;;69476:12:::1;::::0;69531:21:::1;::::0;69580:10:::1;:61:::0;;::::1;::::0;::::1;::::0;:242:::1;::::0;69660:9;;69476:12;;69708:4;;69739::::1;::::0;69476:12;;69792:15:::1;::::0;69580:242:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;69563:673;;69916:237;::::0;-1:-1:-1;;;69916:237:0;;-1:-1:-1;;;;;69916:10:0::1;:61;::::0;::::1;::::0;:237:::1;::::0;70000:9;;70032:1:::1;::::0;70056:4;;70091::::1;::::0;70119:15:::1;::::0;69916:237:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;69895:330:::0;::::1;;70196:4;70186:14;;69895:330;69563:673;;;69857:4;69847:14;;69563:673;70251:7;70246:47;;70275:7;;;;;;;;;70246:47;70305:45;70323:4;64057:42;70336:13;70305:9;:45::i;:::-;70386:10;::::0;70361:53:::1;::::0;70379:4:::1;::::0;-1:-1:-1;;;;;70386:10:0::1;70398:15:::0;70361:9:::1;:53::i;:::-;70425:23;70451:37;70475:13:::0;70451:21:::1;:37;:::i;:::-;70425:63;;70499:25;70563:7;;70548:12;;70538:7;;70527:8;;:18;;;;:::i;:::-;:33;;;;:::i;:::-;:43;;;;:::i;:::-;70499:71;;70581:27;70655:17;70630:7;;70612:15;:25;;;;:::i;:::-;70611:62;;;;:::i;:::-;70581:92:::0;-1:-1:-1;70684:26:0::1;70713:37;70581:92:::0;70713:15;:37:::1;:::i;:::-;70791:10;::::0;70860:12:::1;::::0;;70762:15:::1;70860:12:::0;;;::::1;::::0;::::1;::::0;;;;70684:66;;-1:-1:-1;;;;;;70791:10:0;;::::1;::::0;70829:19;;70783:90:::1;::::0;70860:12;70783:90:::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;70914:9:0::1;::::0;70981:12:::1;::::0;;70885:15:::1;70981:12:::0;;;::::1;::::0;::::1;::::0;;;;70761:112;;-1:-1:-1;;;;;;70914:9:0;;::::1;::::0;70951:18;;70906:88:::1;::::0;70981:12;70906:88:::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;71011:19:0::1;::::0;70884:110;;-1:-1:-1;;;;71011:19:0;::::1;;;71007:62;;;71047:10;:8;:10::i;:::-;71086:250;::::0;;16856:25:1;;;16912:2;16897:18;;16890:34;;;16940:18;;;16933:34;;;16998:2;16983:18;;16976:34;;;17041:3;17026:19;;17019:35;;;17098:14;;17091:22;17085:3;17070:19;;17063:51;17158:14;;17151:22;17145:3;17130:19;;17123:51;71310:15:0::1;17205:3:1::0;17190:19;;17183:35;71086:250:0::1;::::0;16843:3:1;16828:19;71086:250:0::1;;;;;;;68893:2451;;;;;;;;;;;;;62424:1;62436:6:::0;:14;;-1:-1:-1;;;;62436:14:0;;;68855:2489::o;47807:183::-;47905:4;47929:53;47937:3;-1:-1:-1;;;;;47957:23:0;;47929:7;:53::i;48825:183::-;48924:7;48975:22;48979:3;48991:5;48975:3;:22::i;48076:192::-;-1:-1:-1;;;;;48235:23:0;;48181:4;43237:19;;;:12;;;:19;;;;;;:24;;48205:55;43115:154;12524:877;-1:-1:-1;;;;;12655:18:0;;12647:68;;;;-1:-1:-1;;;12647:68:0;;17431:2:1;12647:68:0;;;17413:21:1;17470:2;17450:18;;;17443:30;17509:34;17489:18;;;17482:62;-1:-1:-1;;;17560:18:1;;;17553:35;17605:19;;12647:68:0;17229:401:1;12647:68:0;-1:-1:-1;;;;;12734:16:0;;12726:64;;;;-1:-1:-1;;;12726:64:0;;17837:2:1;12726:64:0;;;17819:21:1;17876:2;17856:18;;;17849:30;17915:34;17895:18;;;17888:62;-1:-1:-1;;;17966:18:1;;;17959:33;18009:19;;12726:64:0;17635:399:1;12726:64:0;-1:-1:-1;;;;;12876:15:0;;12854:19;12876:15;;;;;;;;;;;12924:21;;;;12902:109;;;;-1:-1:-1;;;12902:109:0;;18241:2:1;12902:109:0;;;18223:21:1;18280:2;18260:18;;;18253:30;18319:34;18299:18;;;18292:62;-1:-1:-1;;;18370:18:1;;;18363:36;18416:19;;12902:109:0;18039:402:1;12902:109:0;-1:-1:-1;;;;;13047:15:0;;;:9;:15;;;;;;;;;;;13065:20;;;13047:38;;13265:13;;;;;;;;;;:23;;;;;;13317:26;;160:25:1;;;13265:13:0;;13317:26;;133:18:1;13317:26:0;;;;;;;13356:37;31683:214;65067:1037;65186:10;;-1:-1:-1;;;;;65225:18:0;;65221:45;;-1:-1:-1;65253:5:0;;-1:-1:-1;65253:5:0;65245:21;;65221:45;65277:14;65315:4;-1:-1:-1;;;;;65294:34:0;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65277:53;;65341:14;65379:4;-1:-1:-1;;;;;65358:34:0;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65341:53;;65406:10;65418;65457:4;-1:-1:-1;;;;;65436:53:0;;:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65405:86;;;;;;65502:18;65531:25;65589:4;-1:-1:-1;;;;;65571:23:0;:6;-1:-1:-1;;;;;65571:23:0;;65567:201;;-1:-1:-1;65624:6:0;;-1:-1:-1;65665:2:0;65567:201;;;-1:-1:-1;65713:6:0;;-1:-1:-1;65754:2:0;65567:201;65793:43;;-1:-1:-1;;;65793:43:0;;-1:-1:-1;;;;;4101:32:1;;;65793:43:0;;;4083:51:1;65778:12:0;;65793:28;;;;;;4056:18:1;;65793:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65778:58;;65851:10;65858:2;65851:6;:10::i;:::-;65847:119;;;65889:17;-1:-1:-1;;;;;65882:24:0;:4;:24;65878:77;;;65935:4;65927:12;;65878:77;65980:12;65987:4;65980:6;:12::i;:::-;65976:121;;;66020:17;-1:-1:-1;;;;;66013:24:0;:4;:24;66009:77;;;66066:4;66058:12;;66009:77;65210:894;;;;;;;65067:1037;;;;;;;:::o;68608:239::-;68695:6;;68657:4;;-1:-1:-1;;;68695:6:0;;;;68694:7;:35;;;;-1:-1:-1;68718:11:0;;-1:-1:-1;;;68718:11:0;;;;68694:35;:62;;;;-1:-1:-1;74133:10:0;;:15;;68746:10;68694:107;;;;-1:-1:-1;68791:4:0;68800:1;8271:18;;;;;;;;;;;68773:28;68694:107;:145;;;;-1:-1:-1;68819:20:0;4593:10;78558:110;:::i;68819:20::-;68818:21;68674:165;;68608:239;:::o;74933:266::-;75025:7;75045:17;75087:14;;75075:8;;75066:6;:17;;;;:::i;:::-;75065:36;;;;:::i;:::-;75045:56;;75112:43;75122:6;75138:4;75145:9;75112;:43::i;:::-;75173:18;75182:9;75173:6;:18;:::i;:::-;75166:25;74933:266;-1:-1:-1;;;;74933:266:0:o;35147:802::-;35571:23;35597:106;35639:4;35597:106;;;;;;;;;;;;;;;;;35605:5;-1:-1:-1;;;;;35597:27:0;;;:106;;;;;:::i;:::-;35718:17;;35571:132;;-1:-1:-1;35718:21:0;35714:228;;35833:10;35822:30;;;;;;;;;;;;:::i;:::-;35796:134;;;;-1:-1:-1;;;35796:134:0;;19724:2:1;35796:134:0;;;19706:21:1;19763:2;19743:18;;;19736:30;19802:34;19782:18;;;19775:62;-1:-1:-1;;;19853:18:1;;;19846:40;19903:19;;35796:134:0;19522:406:1;41019:414:0;41082:4;43237:19;;;:12;;;:19;;;;;;41099:327;;-1:-1:-1;41142:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;41325:18;;41303:19;;;:12;;;:19;;;;;;:40;;;;41358:11;;41099:327;-1:-1:-1;41409:5:0;41402:12;;71352:1239;71419:16;;;71433:1;71419:16;;;;;;;;71392:24;;71419:16;;;;;;;;;;-1:-1:-1;71419:16:0;71392:43;;71467:4;71446:7;71454:1;71446:10;;;;;;;;:::i;:::-;;;;;;:26;-1:-1:-1;;;;;71446:26:0;;;-1:-1:-1;;;;;71446:26:0;;;;;71504:4;71483:7;71491:1;71483:10;;;;;;;;:::i;:::-;-1:-1:-1;;;;;71483:26:0;;;;:10;;;;;;;;;;:26;71562:4;71522:19;8271:18;;;;;;;;;;;;71594:15;71608:1;8271:18;71594:15;:::i;:::-;71579:30;;71631:4;71624;:11;71620:24;;;71637:7;;;71352:1239::o;71620:24::-;71762:240;;-1:-1:-1;;;71762:240:0;;71682:21;;71656:23;;-1:-1:-1;;;;;71762:10:0;:61;;;;:240;;71842:4;;71656:23;;71885:7;;71919:4;;71656:23;;71972:15;;71762:240;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71745:669;;72096:235;;-1:-1:-1;;;72096:235:0;;-1:-1:-1;;;;;72096:10:0;:61;;;;:235;;72180:4;;72207:1;;72231:7;;72269:4;;72297:15;;72096:235;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72075:328;;;-1:-1:-1;72374:4:0;72075:328;71745:669;;;-1:-1:-1;72037:4:0;71745:669;72429:7;72424:47;;72453:7;;;;;71352:1239::o;72424:47::-;72483:17;72503:39;72527:15;72503:21;:39;:::i;:::-;72483:59;;72553:30;72567:4;72573:9;72553:13;:30::i;41609:1420::-;41675:4;41814:19;;;:12;;;:19;;;;;;41850:15;;41846:1176;;42225:21;42249:14;42262:1;42249:10;:14;:::i;:::-;42298:18;;42225:38;;-1:-1:-1;42278:17:0;;42298:22;;42319:1;;42298:22;:::i;:::-;42278:42;;42354:13;42341:9;:26;42337:405;;42388:17;42408:3;:11;;42420:9;42408:22;;;;;;;;:::i;:::-;;;;;;;;;42388:42;;42562:9;42533:3;:11;;42545:13;42533:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;42647:23;;;:12;;;:23;;;;;:36;;;42337:405;42823:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;42918:3;:12;;:19;42931:5;42918:19;;;;;;;;;;;42911:26;;;42961:4;42954:11;;;;;;;41846:1176;43005:5;42998:12;;;;;43818:145;43910:7;43937:3;:11;;43949:5;43937:18;;;;;;;;:::i;:::-;;;;;;;;;43930:25;;43818:145;;;;:::o;24861:229::-;24998:12;25030:52;25052:6;25060:4;25066:1;25069:12;25030:21;:52::i;73471:511::-;73554:57;73571:4;73586:10;73599:11;73554:8;:57::i;:::-;73812:9;;;73639:232;;-1:-1:-1;;;73639:232:0;;73710:4;73639:232;;;20406:34:1;20456:18;;;20449:34;;;73764:1:0;20499:18:1;;;20492:34;;;20542:18;;;20535:34;-1:-1:-1;;;;;73812:9:0;;;20585:19:1;;;20578:44;73841:15:0;20638:19:1;;;20631:35;73639:10:0;:26;;;;73673:9;;20340:19:1;;73639:232:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73639:232:0;;;;;;;;-1:-1:-1;;73639:232:0;;;;;;;;;;;;:::i;:::-;;;73622:353;;;-1:-1:-1;;73901:53:0;;;21190:25:1;;;21246:2;21231:18;;21224:34;;;73938:15:0;21274:18:1;;;21267:34;73901:53:0;;;;-1:-1:-1;73901:53:0;;;;21178:2:1;73901:53:0;;;73471:511;;:::o;26077:612::-;26247:12;26319:5;26294:21;:30;;26272:118;;;;-1:-1:-1;;;26272:118:0;;21514:2:1;26272:118:0;;;21496:21:1;21553:2;21533:18;;;21526:30;21592:34;21572:18;;;21565:62;-1:-1:-1;;;21643:18:1;;;21636:36;21689:19;;26272:118:0;21312:402:1;26272:118:0;26402:12;26416:23;26443:6;-1:-1:-1;;;;;26443:11:0;26462:5;26483:4;26443:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26401:97;;;;26529:152;26574:6;26599:7;26625:10;26654:12;26529:26;:152::i;:::-;26509:172;26077:612;-1:-1:-1;;;;;;;26077:612:0:o;29207:644::-;29392:12;29421:7;29417:427;;;29449:10;:17;29470:1;29449:22;29445:290;;-1:-1:-1;;;;;22204:19:0;;;29659:60;;;;-1:-1:-1;;;29659:60:0;;21921:2:1;29659:60:0;;;21903:21:1;21960:2;21940:18;;;21933:30;21999:31;21979:18;;;21972:59;22048:18;;29659:60:0;21719:353:1;29659:60:0;-1:-1:-1;29756:10:0;29749:17;;29417:427;29799:33;29807:10;29819:12;30579:17;;:21;30575:388;;30811:10;30805:17;30868:15;30855:10;30851:2;30847:19;30840:44;30575:388;30938:12;30931:20;;-1:-1:-1;;;30931:20:0;;;;;;;;:::i;196:250:1:-;281:1;291:113;305:6;302:1;299:13;291:113;;;381:11;;;375:18;362:11;;;355:39;327:2;320:10;291:113;;;-1:-1:-1;;438:1:1;420:16;;413:27;196:250::o;451:396::-;600:2;589:9;582:21;563:4;632:6;626:13;675:6;670:2;659:9;655:18;648:34;691:79;763:6;758:2;747:9;743:18;738:2;730:6;726:15;691:79;:::i;:::-;831:2;810:15;-1:-1:-1;;806:29:1;791:45;;;;838:2;787:54;;451:396;-1:-1:-1;;451:396:1:o;852:131::-;-1:-1:-1;;;;;927:31:1;;917:42;;907:70;;973:1;970;963:12;988:315;1056:6;1064;1117:2;1105:9;1096:7;1092:23;1088:32;1085:52;;;1133:1;1130;1123:12;1085:52;1172:9;1159:23;1191:31;1216:5;1191:31;:::i;:::-;1241:5;1293:2;1278:18;;;;1265:32;;-1:-1:-1;;;988:315:1:o;1500:456::-;1577:6;1585;1593;1646:2;1634:9;1625:7;1621:23;1617:32;1614:52;;;1662:1;1659;1652:12;1614:52;1701:9;1688:23;1720:31;1745:5;1720:31;:::i;:::-;1770:5;-1:-1:-1;1827:2:1;1812:18;;1799:32;1840:33;1799:32;1840:33;:::i;:::-;1500:456;;1892:7;;-1:-1:-1;;;1946:2:1;1931:18;;;;1918:32;;1500:456::o;2150:247::-;2209:6;2262:2;2250:9;2241:7;2237:23;2233:32;2230:52;;;2278:1;2275;2268:12;2230:52;2317:9;2304:23;2336:31;2361:5;2336:31;:::i;2402:454::-;2497:6;2505;2513;2521;2529;2582:3;2570:9;2561:7;2557:23;2553:33;2550:53;;;2599:1;2596;2589:12;2550:53;-1:-1:-1;;2622:23:1;;;2692:2;2677:18;;2664:32;;-1:-1:-1;2743:2:1;2728:18;;2715:32;;2794:2;2779:18;;2766:32;;-1:-1:-1;2845:3:1;2830:19;2817:33;;-1:-1:-1;2402:454:1;-1:-1:-1;2402:454:1:o;2861:118::-;2947:5;2940:13;2933:21;2926:5;2923:32;2913:60;;2969:1;2966;2959:12;2984:241;3040:6;3093:2;3081:9;3072:7;3068:23;3064:32;3061:52;;;3109:1;3106;3099:12;3061:52;3148:9;3135:23;3167:28;3189:5;3167:28;:::i;3230:382::-;3295:6;3303;3356:2;3344:9;3335:7;3331:23;3327:32;3324:52;;;3372:1;3369;3362:12;3324:52;3411:9;3398:23;3430:31;3455:5;3430:31;:::i;:::-;3480:5;-1:-1:-1;3537:2:1;3522:18;;3509:32;3550:30;3509:32;3550:30;:::i;:::-;3599:7;3589:17;;;3230:382;;;;;:::o;3617:315::-;3685:6;3693;3746:2;3734:9;3725:7;3721:23;3717:32;3714:52;;;3762:1;3759;3752:12;3714:52;3798:9;3785:23;3775:33;;3858:2;3847:9;3843:18;3830:32;3871:31;3896:5;3871:31;:::i;4145:180::-;4204:6;4257:2;4245:9;4236:7;4232:23;4228:32;4225:52;;;4273:1;4270;4263:12;4225:52;-1:-1:-1;4296:23:1;;4145:180;-1:-1:-1;4145:180:1:o;4330:523::-;4434:6;4442;4450;4458;4466;4474;4527:3;4515:9;4506:7;4502:23;4498:33;4495:53;;;4544:1;4541;4534:12;4495:53;-1:-1:-1;;4567:23:1;;;4637:2;4622:18;;4609:32;;-1:-1:-1;4688:2:1;4673:18;;4660:32;;4739:2;4724:18;;4711:32;;-1:-1:-1;4790:3:1;4775:19;;4762:33;;-1:-1:-1;4842:3:1;4827:19;4814:33;;-1:-1:-1;4330:523:1;-1:-1:-1;4330:523:1:o;4858:388::-;4926:6;4934;4987:2;4975:9;4966:7;4962:23;4958:32;4955:52;;;5003:1;5000;4993:12;4955:52;5042:9;5029:23;5061:31;5086:5;5061:31;:::i;:::-;5111:5;-1:-1:-1;5168:2:1;5153:18;;5140:32;5181:33;5140:32;5181:33;:::i;5251:529::-;5328:6;5336;5344;5397:2;5385:9;5376:7;5372:23;5368:32;5365:52;;;5413:1;5410;5403:12;5365:52;5452:9;5439:23;5471:31;5496:5;5471:31;:::i;:::-;5521:5;-1:-1:-1;5578:2:1;5563:18;;5550:32;5591:33;5550:32;5591:33;:::i;:::-;5643:7;-1:-1:-1;5702:2:1;5687:18;;5674:32;5715:33;5674:32;5715:33;:::i;:::-;5767:7;5757:17;;;5251:529;;;;;:::o;6130:380::-;6209:1;6205:12;;;;6252;;;6273:61;;6327:4;6319:6;6315:17;6305:27;;6273:61;6380:2;6372:6;6369:14;6349:18;6346:38;6343:161;;6426:10;6421:3;6417:20;6414:1;6407:31;6461:4;6458:1;6451:15;6489:4;6486:1;6479:15;6343:161;;6130:380;;;:::o;6515:127::-;6576:10;6571:3;6567:20;6564:1;6557:31;6607:4;6604:1;6597:15;6631:4;6628:1;6621:15;6647:128;6714:9;;;6735:11;;;6732:37;;;6749:18;;:::i;6780:125::-;6845:9;;;6866:10;;;6863:36;;;6879:18;;:::i;6910:184::-;6980:6;7033:2;7021:9;7012:7;7008:23;7004:32;7001:52;;;7049:1;7046;7039:12;7001:52;-1:-1:-1;7072:16:1;;6910:184;-1:-1:-1;6910:184:1:o;7756:251::-;7826:6;7879:2;7867:9;7858:7;7854:23;7850:32;7847:52;;;7895:1;7892;7885:12;7847:52;7927:9;7921:16;7946:31;7971:5;7946:31;:::i;8355:245::-;8434:6;8442;8495:2;8483:9;8474:7;8470:23;8466:32;8463:52;;;8511:1;8508;8501:12;8463:52;-1:-1:-1;;8534:16:1;;8590:2;8575:18;;;8569:25;8534:16;;8569:25;;-1:-1:-1;8355:245:1:o;8605:168::-;8678:9;;;8709;;8726:15;;;8720:22;;8706:37;8696:71;;8747:18;;:::i;8778:217::-;8818:1;8844;8834:132;;8888:10;8883:3;8879:20;8876:1;8869:31;8923:4;8920:1;8913:15;8951:4;8948:1;8941:15;8834:132;-1:-1:-1;8980:9:1;;8778:217::o;9406:398::-;9608:2;9590:21;;;9647:2;9627:18;;;9620:30;9686:34;9681:2;9666:18;;9659:62;-1:-1:-1;;;9752:2:1;9737:18;;9730:32;9794:3;9779:19;;9406:398::o;10299:287::-;10428:3;10466:6;10460:13;10482:66;10541:6;10536:3;10529:4;10521:6;10517:17;10482:66;:::i;:::-;10564:16;;;;;10299:287;-1:-1:-1;;10299:287:1:o;14651:127::-;14712:10;14707:3;14703:20;14700:1;14693:31;14743:4;14740:1;14733:15;14767:4;14764:1;14757:15;14783:461;14836:3;14874:5;14868:12;14901:6;14896:3;14889:19;14927:4;14956:2;14951:3;14947:12;14940:19;;14993:2;14986:5;14982:14;15014:1;15024:195;15038:6;15035:1;15032:13;15024:195;;;15103:13;;-1:-1:-1;;;;;15099:39:1;15087:52;;15159:12;;;;15194:15;;;;15135:1;15053:9;15024:195;;;-1:-1:-1;15235:3:1;;14783:461;-1:-1:-1;;;;;14783:461:1:o;15249:684::-;15576:6;15565:9;15558:25;15619:6;15614:2;15603:9;15599:18;15592:34;15662:3;15657:2;15646:9;15642:18;15635:31;15539:4;15683:57;15735:3;15724:9;15720:19;15712:6;15683:57;:::i;:::-;-1:-1:-1;;;;;15814:15:1;;;15809:2;15794:18;;15787:43;15867:15;;;;15861:3;15846:19;;15839:44;15767:3;15899:19;15892:35;15675:65;15249:684;-1:-1:-1;;;;15249:684:1:o;15938:582::-;16237:6;16226:9;16219:25;16280:6;16275:2;16264:9;16260:18;16253:34;16323:3;16318:2;16307:9;16303:18;16296:31;16200:4;16344:57;16396:3;16385:9;16381:19;16373:6;16344:57;:::i;:::-;-1:-1:-1;;;;;16437:32:1;;;;16432:2;16417:18;;16410:60;-1:-1:-1;16501:3:1;16486:19;16479:35;16336:65;15938:582;-1:-1:-1;;;15938:582:1:o;18446:188::-;18525:13;;-1:-1:-1;;;;;18567:42:1;;18557:53;;18547:81;;18624:1;18621;18614:12;18639:163;18717:13;;18770:6;18759:18;;18749:29;;18739:57;;18792:1;18789;18782:12;18807:460;18902:6;18910;18918;18926;18979:3;18967:9;18958:7;18954:23;18950:33;18947:53;;;18996:1;18993;18986:12;18947:53;19019:40;19049:9;19019:40;:::i;:::-;19009:50;;19078:49;19123:2;19112:9;19108:18;19078:49;:::i;:::-;19068:59;;19146:48;19190:2;19179:9;19175:18;19146:48;:::i;:::-;19136:58;;19213:48;19257:2;19246:9;19242:18;19213:48;:::i;:::-;19203:58;;18807:460;;;;;;;:::o;19272:245::-;19339:6;19392:2;19380:9;19371:7;19367:23;19363:32;19360:52;;;19408:1;19405;19398:12;19360:52;19440:9;19434:16;19459:28;19481:5;19459:28;:::i;19933:127::-;19994:10;19989:3;19985:20;19982:1;19975:31;20025:4;20022:1;20015:15;20049:4;20046:1;20039:15;20677:306;20765:6;20773;20781;20834:2;20822:9;20813:7;20809:23;20805:32;20802:52;;;20850:1;20847;20840:12;20802:52;20879:9;20873:16;20863:26;;20929:2;20918:9;20914:18;20908:25;20898:35;;20973:2;20962:9;20958:18;20952:25;20942:35;;20677:306;;;;;:::o

ipfs://b4a6b78cd85aa48a7b1f845ade3ce5a3d4d858b50fd9ff06a05a85f30e4b5d87