Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

pragma solidity ^0.8.0;



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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;



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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }
}

// File: contracts/interfaces/ICamelotFactory.sol


pragma solidity >=0.5.0;

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

    function owner() external view returns (address);

    function feePercentOwner() external view returns (address);

    function setStableOwner() external view returns (address);

    function feeTo() external view returns (address);

    function ownerFeeShare() external view returns (uint256);

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

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

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

    function allPairsLength() external view returns (uint256);

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

    function setFeeTo(address) external;

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

// File: contracts/interfaces/IUniswapV2Router01.sol


pragma solidity >=0.6.2;

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

    function WETH() external pure returns (address);

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

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

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

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

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

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

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

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

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

// File: contracts/interfaces/ICamelotRouter.sol


pragma solidity >=0.6.2;

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

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

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

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

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

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

// File: contracts/interfaces/IJackpot.sol


pragma solidity >=0.5.0;

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

// File: contracts/interfaces/IWETH.sol


pragma solidity >=0.5.0;

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

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

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

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

    function deposit() external payable;

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

    function withdraw(uint256) external;
}

// File: contracts/interfaces/IDogeBonusPool.sol


pragma solidity >=0.5.0;

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

// File: contracts/token/0xApepe.sol


pragma solidity =0.8.19;











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

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

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

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

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

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

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

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

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

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

    EnumerableSet.AddressSet private _pairs;

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

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

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

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

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

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

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

        if (totalFee == 0) {
            shouldTakeFee = false;
        }

        if (shouldSwapBack() && totalFee != 0) {
            swapBack();
        }

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

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

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

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

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

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

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

        _transfer(address(this), DEAD, amountDogBurn);
        if (!bonusEnabled) {
            _transfer(address(this), bonusWallet, amountDogBonus);    
        } else {
            _approve(address(this), address(bonusWallet), amountDogBonus);
            IDogeBonusPool(bonusWallet).injectRewards(amountDogBonus);
        } 
        
        uint256 amountBackToken = backToken.balanceOf(address(this)) - balanceBefore;
        uint256 backTokenTotalFee = totalFee - burnFee - liquidityFee - bonusFee;
        if (backTokenTotalFee != 0) {
            uint256 amountBackTokenGov1 = (amountBackToken * gov1Fee) / (backTokenTotalFee);
            uint256 amountBackTokenGov2 = (amountBackToken * gov2Fee) / (backTokenTotalFee);
            uint256 amountBackTokenJackpot = (amountBackToken * jackpotFee) / backTokenTotalFee;
            uint256 amountBackTokenDev = amountBackToken - amountBackTokenGov1 - amountBackTokenGov2 - amountBackTokenJackpot;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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 setBonusEnabled(bool _enabled) external onlyOwner {
        require(!shouldSwapBack(), "0xApepe: stop auto swapback first");
        bonusEnabled = _enabled;
    }

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

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

    function delPair(address pair) public onlyOwner returns (bool) {
        require(pair != address(0), "0xApepe: 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, "0xApepe: index out of bounds");
        return _pairs.at(index);
    }

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

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

60e06040526005805462ffffff60a01b19166201010160a01b17905561271060105560646011819055601281905560c8601381905560148190556015819055601681905560178190556104b060188190556019839055601a92909255601b819055601c819055601d819055601e819055601f556020553480156200008257600080fd5b50604051620041a3380380620041a3833981016040819052620000a59162000316565b6040805180820182526007808252663078417065706560c81b6020808401829052845180860190955291845290830152906003620000e4838262000422565b506004620000f3828262000422565b505050620001106200010a620001dc60201b60201c565b620001e0565b602780546001600160a01b0319166001600160a01b0386161790556958f03ee118a13e800000600160076000620001443390565b6001600160a01b03908116825260208083019390935260409182016000908120805495151560ff19968716179055308082526007855283822080548716600190811790915533835260069095528382208054871686179055815291909120805490931690911790915584811660805283811660a052821660c052620001d1620001ca3390565b8262000232565b505050505062000516565b3390565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6001600160a01b0382166200028d5760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f206164647265737300604482015260640160405180910390fd5b8060026000828254620002a19190620004ee565b90915550506001600160a01b038216600081815260208181526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a35050565b505050565b6001600160a01b03811681146200031357600080fd5b50565b600080600080608085870312156200032d57600080fd5b84516200033a81620002fd565b60208601519094506200034d81620002fd565b60408601519093506200036081620002fd565b60608601519092506200037381620002fd565b939692955090935050565b634e487b7160e01b600052604160045260246000fd5b600181811c90821680620003a957607f821691505b602082108103620003ca57634e487b7160e01b600052602260045260246000fd5b50919050565b601f821115620002f857600081815260208120601f850160051c81016020861015620003f95750805b601f850160051c820191505b818110156200041a5782815560010162000405565b505050505050565b81516001600160401b038111156200043e576200043e6200037e565b62000456816200044f845462000394565b84620003d0565b602080601f8311600181146200048e5760008415620004755750858301515b600019600386901b1c1916600185901b1785556200041a565b600085815260208120601f198616915b82811015620004bf578886015182559484019460019091019084016200049e565b5085821015620004de5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b808201808211156200051057634e487b7160e01b600052601160045260246000fd5b92915050565b60805160a05160c051613c256200057e600039600081816110b7015281816122490152612fd301526000818161212e0152818161239c0152818161244801528181613098015281816131430152818161331c01526133aa015260006110e80152613c256000f3fe6080604052600436106103b15760003560e01c8063861faf5f116101e7578063bdf391cc1161010d578063dbd6c489116100a0578063e5e31b131161006f578063e5e31b1314610ae4578063f2fde38b14610b04578063fb5f27fb14610b24578063ff4620e714610b3a57600080fd5b8063dbd6c48914610a45578063dd62ed3e14610a5b578063df8069cd14610aae578063e1e5a66d14610ace57600080fd5b8063c6d2577d116100dc578063c6d2577d146109ce578063cb806e07146109e4578063cdba31fd146109fa578063d830678614610a1057600080fd5b8063bdf391cc14610963578063bf56b37114610983578063bfa382b514610999578063c2b7bbb6146109ae57600080fd5b8063a457c2d711610185578063ace1880111610154578063ace1880114610901578063b6309f6814610917578063b7eed4c41461092d578063b8c611301461094357600080fd5b8063a457c2d714610881578063a5bc5085146108a1578063a9059cbb146108c1578063aac46c95146108e157600080fd5b80638fbbd750116101c15780638fbbd750146108175780639272293c1461082c57806395d89b411461084c57806398d976501461086157600080fd5b8063861faf5f146107a957806386c8782f146107d65780638da5cb5b146107ec57600080fd5b8063313ce567116102d75780636c4705951161026a578063715018a611610239578063715018a61461071b5780638072250b1461073057806382d2011614610760578063860139401461077657600080fd5b80636c4705951461067a5780636ddd17131461069057806370a08231146106c257806370c8810e1461070557600080fd5b80634460d3cf116102a65780634460d3cf1461060f5780634fab9e4c1461062f5780635314841614610644578063658d4b7f1461065a57600080fd5b8063313ce5671461058e578063364333f4146105aa57806339509351146105bf5780633f4218e0146105df57600080fd5b806312835c5e1161034f578063234a2daa1161031e578063234a2daa146104f157806323b872dd146105075780632b112e49146105275780632d2f244b1461053c57600080fd5b806312835c5e1461049a57806315674e8e146104b0578063180b0d7e146104c657806318160ddd146104dc57600080fd5b806306fdde031161038b57806306fdde0314610412578063095ea7b3146104345780630ca5979b146104645780631107b3a51461048457600080fd5b806301339c21146103bd578063017e24e1146103d45780630323aac7146103fd57600080fd5b366103b857005b600080fd5b3480156103c957600080fd5b506103d2610b6e565b005b3480156103e057600080fd5b506103ea600a5481565b6040519081526020015b60405180910390f35b34801561040957600080fd5b506103ea610bef565b34801561041e57600080fd5b50610427610c00565b6040516103f49190613699565b34801561044057600080fd5b5061045461044f36600461370c565b610c92565b60405190151581526020016103f4565b34801561047057600080fd5b506103d261047f366004613738565b610cac565b34801561049057600080fd5b506103ea601c5481565b3480156104a657600080fd5b506103ea601f5481565b3480156104bc57600080fd5b506103ea60115481565b3480156104d257600080fd5b506103ea60105481565b3480156104e857600080fd5b506002546103ea565b3480156104fd57600080fd5b506103ea60195481565b34801561051357600080fd5b50610454610522366004613784565b610d24565b34801561053357600080fd5b506103ea610d48565b34801561054857600080fd5b506024546105699073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016103f4565b34801561059a57600080fd5b50604051600681526020016103f4565b3480156105b657600080fd5b506103d2610daf565b3480156105cb57600080fd5b506104546105da36600461370c565b610eff565b3480156105eb57600080fd5b506104546105fa3660046137c5565b60066020526000908152604090205460ff1681565b34801561061b57600080fd5b506103d261062a3660046137c5565b610f4b565b34801561063b57600080fd5b506103d2611005565b34801561065057600080fd5b506103ea60205481565b34801561066657600080fd5b506103d26106753660046137f0565b611193565b34801561068657600080fd5b506103ea60155481565b34801561069c57600080fd5b506005546104549074010000000000000000000000000000000000000000900460ff1681565b3480156106ce57600080fd5b506103ea6106dd3660046137c5565b73ffffffffffffffffffffffffffffffffffffffff1660009081526020819052604090205490565b34801561071157600080fd5b506103ea60125481565b34801561072757600080fd5b506103d26111f1565b34801561073c57600080fd5b5061045461074b3660046137c5565b60076020526000908152604090205460ff1681565b34801561076c57600080fd5b506103ea60145481565b34801561078257600080fd5b50600554610454907501000000000000000000000000000000000000000000900460ff1681565b3480156107b557600080fd5b506027546105699073ffffffffffffffffffffffffffffffffffffffff1681565b3480156107e257600080fd5b506103ea60165481565b3480156107f857600080fd5b5060055473ffffffffffffffffffffffffffffffffffffffff16610569565b34801561082357600080fd5b506103d2611205565b34801561083857600080fd5b506103d2610847366004613738565b611215565b34801561085857600080fd5b5061042761128d565b34801561086d57600080fd5b506103d261087c366004613829565b61129c565b34801561088d57600080fd5b5061045461089c36600461370c565b611385565b3480156108ad57600080fd5b506104546108bc3660046137c5565b611461565b3480156108cd57600080fd5b506104546108dc36600461370c565b611519565b3480156108ed57600080fd5b506103d26108fc366004613829565b611526565b34801561090d57600080fd5b506103ea601e5481565b34801561092357600080fd5b506103ea601b5481565b34801561093957600080fd5b506103ea601d5481565b34801561094f57600080fd5b506103d261095e366004613829565b611579565b34801561096f57600080fd5b5061056961097e366004613846565b6115cb565b34801561098f57600080fd5b506103ea60285481565b3480156109a557600080fd5b506103d2611657565b3480156109ba57600080fd5b506104546109c93660046137c5565b611732565b3480156109da57600080fd5b506103ea60295481565b3480156109f057600080fd5b506103ea60095481565b348015610a0657600080fd5b506103ea60175481565b348015610a1c57600080fd5b506005546104549077010000000000000000000000000000000000000000000000900460ff1681565b348015610a5157600080fd5b506103ea601a5481565b348015610a6757600080fd5b506103ea610a7636600461385f565b73ffffffffffffffffffffffffffffffffffffffff918216600090815260016020908152604080832093909416825291909152205490565b348015610aba57600080fd5b506103d2610ac936600461388d565b6117ea565b348015610ada57600080fd5b506103ea60135481565b348015610af057600080fd5b50610454610aff3660046137c5565b611886565b348015610b1057600080fd5b506103d2610b1f3660046137c5565b611893565b348015610b3057600080fd5b506103ea60185481565b348015610b4657600080fd5b5060055461045490760100000000000000000000000000000000000000000000900460ff1681565b610b76611947565b60285415610be5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601060248201527f416c7265616479206c61756e636865640000000000000000000000000000000060448201526064015b60405180910390fd5b4360285542602955565b6000610bfb602b6119c8565b905090565b606060038054610c0f9061390f565b80601f0160208091040260200160405190810160405280929190818152602001828054610c3b9061390f565b8015610c885780601f10610c5d57610100808354040283529160200191610c88565b820191906000526020600020905b815481529060010190602001808311610c6b57829003601f168201915b5050505050905090565b600033610ca08185856119d2565b60019150505b92915050565b610cb4611947565b60128790556013869055601485905560158490556016839055601782905560118190558082848688610ce68b8d613991565b610cf09190613991565b610cfa9190613991565b610d049190613991565b610d0e9190613991565b610d189190613991565b60185550505050505050565b600033610d32858285611b85565b610d3d858585611c5c565b9150505b9392505050565b600060208190527fad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb55461dead82527f44ad89ba62b98ff34f51403ac22759b55759460c0bb5521eb4b6ee3cff49cf8354600254610da591906139a4565b610bfb91906139a4565b610db7611947565b60275473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb336027546040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff909116906370a0823190602401602060405180830381865afa158015610e44573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e6891906139b7565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e085901b16815273ffffffffffffffffffffffffffffffffffffffff909216600483015260248201526044016020604051808303816000875af1158015610ed8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610efc91906139d0565b50565b33600081815260016020908152604080832073ffffffffffffffffffffffffffffffffffffffff87168452909152812054909190610ca09082908690610f46908790613991565b6119d2565b610f53611947565b6040517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152610efc90339073ffffffffffffffffffffffffffffffffffffffff8416906370a0823190602401602060405180830381865afa158015610fc3573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610fe791906139b7565b73ffffffffffffffffffffffffffffffffffffffff84169190611fa9565b61100d611947565b602a5460ff161561107a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601360248201527f416c726561647920696e697469616c697a6564000000000000000000000000006044820152606401610bdc565b6040517fc9c6539600000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000811660048301523060248301526000917f00000000000000000000000000000000000000000000000000000000000000009091169063c9c65396906044016020604051808303816000875af1158015611133573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061115791906139ed565b9050611164602b8261203b565b5050602a80547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055565b61119b611947565b73ffffffffffffffffffffffffffffffffffffffff91909116600090815260066020526040902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016911515919091179055565b6111f9611947565b611203600061205d565b565b61120d611947565b6112036120d4565b61121d611947565b601a879055601b869055601c859055601d849055601e839055601f8290556019819055808284868861124f8b8d613991565b6112599190613991565b6112639190613991565b61126d9190613991565b6112779190613991565b6112819190613991565b60205550505050505050565b606060048054610c0f9061390f565b6112a4611947565b6112ac612a77565b15611339576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f307841706570653a2073746f70206175746f20737761706261636b206669727360448201527f74000000000000000000000000000000000000000000000000000000000000006064820152608401610bdc565b60058054911515760100000000000000000000000000000000000000000000027fffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffff909216919091179055565b33600081815260016020908152604080832073ffffffffffffffffffffffffffffffffffffffff8716845290915281205490919083811015611449576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760448201527f207a65726f0000000000000000000000000000000000000000000000000000006064820152608401610bdc565b61145682868684036119d2565b506001949350505050565b600061146b611947565b73ffffffffffffffffffffffffffffffffffffffff821661150e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f307841706570653a207061697220697320746865207a65726f2061646472657360448201527f73000000000000000000000000000000000000000000000000000000000000006064820152608401610bdc565b610ca6602b83612afe565b6000610d41338484611c5c565b61152e611947565b600580549115157501000000000000000000000000000000000000000000027fffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffffff909216919091179055565b611581611947565b6005805491151574010000000000000000000000000000000000000000027fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff909216919091179055565b600060016115d9602b6119c8565b6115e391906139a4565b82111561164c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f307841706570653a20696e646578206f7574206f6620626f756e6473000000006044820152606401610bdc565b610ca6602b83612b20565b61165f611947565b6040805160008082526020820192839052479290913391849161168191613a0a565b60006040518083038185875af1925050503d80600081146116be576040519150601f19603f3d011682016040523d82523d6000602084013e6116c3565b606091505b505090508061172e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f307841706570653a204554485f5452414e534645525f4641494c4544000000006044820152606401610bdc565b5050565b600061173c611947565b73ffffffffffffffffffffffffffffffffffffffff82166117df576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f307841706570653a207061697220697320746865207a65726f2061646472657360448201527f73000000000000000000000000000000000000000000000000000000000000006064820152608401610bdc565b610ca6602b8361203b565b6117f2611947565b602180547fffffffffffffffffffffffff000000000000000000000000000000000000000090811673ffffffffffffffffffffffffffffffffffffffff98891617909155602280548216968816969096179095556023805486169487169490941790935560248054851692861692909217909155602580548416918516919091179055602680549092169216919091179055565b6000610ca6602b83612b2c565b61189b611947565b73ffffffffffffffffffffffffffffffffffffffff811661193e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f64647265737300000000000000000000000000000000000000000000000000006064820152608401610bdc565b610efc8161205d565b60055473ffffffffffffffffffffffffffffffffffffffff163314611203576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610bdc565b6000610ca6825490565b73ffffffffffffffffffffffffffffffffffffffff8316611a74576040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460448201527f72657373000000000000000000000000000000000000000000000000000000006064820152608401610bdc565b73ffffffffffffffffffffffffffffffffffffffff8216611b17576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f20616464726560448201527f73730000000000000000000000000000000000000000000000000000000000006064820152608401610bdc565b73ffffffffffffffffffffffffffffffffffffffff83811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b73ffffffffffffffffffffffffffffffffffffffff8381166000908152600160209081526040808320938616835292905220547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8114611c565781811015611c49576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000006044820152606401610bdc565b611c5684848484036119d2565b50505050565b60055460009077010000000000000000000000000000000000000000000000900460ff1615611c9857611c90848484612b5b565b506001610d41565b73ffffffffffffffffffffffffffffffffffffffff841660009081526007602052604090205460ff16611d2e57602854611d2e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601460248201527f54726164696e67206e6f74206f70656e207965740000000000000000000000006044820152606401610bdc565b73ffffffffffffffffffffffffffffffffffffffff841660009081526006602052604081205460ff16158015611d8a575073ffffffffffffffffffffffffffffffffffffffff841660009081526006602052604090205460ff16155b8015611d97575060285415155b905060008585611da682611886565b15611e7757611de0601154600855601254600955601354600a55601454600b55601554600c55601654600d55601754600e55601854600f55565b5050602480546040517f67d198a600000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff808a166004830152928101879052600193508792899216906367d198a690604401600060405180830381600087803b158015611e5c57600080fd5b505af1925050508015611e6d575060015b15611ec857611ec8565b611e8087611886565b15611ec357611eba601954600855601a54600955601b54600a55601c54600b55601d54600c55601e54600d55601f54600e55602054600f55565b60029250611ec8565b600093505b600f54600003611ed757600093505b611edf612a77565b8015611eec5750600f5415155b15611ef957611ef96120d4565b600084611f065786611f10565b611f108988612dca565b9050611f1d898983612b5b565b8315611f9a577fe6f814da7244d1ae6c61b54b5684858ba39cad7b9a91884be10060664987d75483838987611f50610d48565b6040805173ffffffffffffffffffffffffffffffffffffffff968716815295909416602086015292840191909152606083015260808201524260a082015260c00160405180910390a15b50600198975050505050505050565b6040805173ffffffffffffffffffffffffffffffffffffffff8416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052612036908490612e07565b505050565b6000610d418373ffffffffffffffffffffffffffffffffffffffff8416612f13565b6005805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600580547fffffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffff1677010000000000000000000000000000000000000000000000179055306000908152602081905260408120549050612153307f0000000000000000000000000000000000000000000000000000000000000000836119d2565b6000600f54600854836121669190613a26565b6121709190613a3d565b90506000600f54600b54846121859190613a26565b61218f9190613a3d565b90506000600f54600d54856121a49190613a26565b6121ae9190613a3d565b90506121ba83856139a4565b93506121c682856139a4565b93506121d281856139a4565b604080516003808252608082019092529195506000919060208201606080368337019050509050308160008151811061220d5761220d613a78565b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff16815250507f00000000000000000000000000000000000000000000000000000000000000008160018151811061227b5761227b613a78565b73ffffffffffffffffffffffffffffffffffffffff92831660209182029290920101526027548251911690829060029081106122b9576122b9613a78565b73ffffffffffffffffffffffffffffffffffffffff92831660209182029290920101526027546040517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152600092839216906370a0823190602401602060405180830381865afa158015612338573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061235c91906139b7565b6040517fac3893ba00000000000000000000000000000000000000000000000000000000815290915073ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000169063ac3893ba906123dc908a906000908890309083904290600401613af8565b600060405180830381600087803b1580156123f657600080fd5b505af1925050508015612407575060015b6124c0576040517f5c11d79500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001690635c11d79590612486908a90600090889030904290600401613b49565b600060405180830381600087803b1580156124a057600080fd5b505af19250505080156124b1575060015b156124bb57600191505b6124c5565b600191505b816124d65750505050505050612a4d565b6124e33061dead88612b5b565b600554760100000000000000000000000000000000000000000000900460ff166125315760235461252c90309073ffffffffffffffffffffffffffffffffffffffff1686612b5b565b6125db565b60235461255690309073ffffffffffffffffffffffffffffffffffffffff16866119d2565b6023546040517f3bdc8a1f0000000000000000000000000000000000000000000000000000000081526004810186905273ffffffffffffffffffffffffffffffffffffffff90911690633bdc8a1f90602401600060405180830381600087803b1580156125c257600080fd5b505af11580156125d6573d6000803e3d6000fd5b505050505b6027546040517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152600091839173ffffffffffffffffffffffffffffffffffffffff909116906370a0823190602401602060405180830381865afa15801561264e573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061267291906139b7565b61267c91906139a4565b90506000600d54600b54600854600f5461269691906139a4565b6126a091906139a4565b6126aa91906139a4565b90508015612a4357600081600954846126c39190613a26565b6126cd9190613a3d565b9050600082600a54856126e09190613a26565b6126ea9190613a3d565b9050600083600c54866126fd9190613a26565b6127079190613a3d565b90506000818361271786896139a4565b61272191906139a4565b61272b91906139a4565b6027546021546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff918216600482015260248101889052929350169063a9059cbb906044016020604051808303816000875af11580156127a8573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906127cc91906139d0565b506027546022546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff91821660048201526024810186905291169063a9059cbb906044016020604051808303816000875af1158015612848573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061286c91906139d0565b50602754602480546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff91821660048201529182018590529091169063a9059cbb906044016020604051808303816000875af11580156128e9573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061290d91906139d0565b506027546025546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff91821660048201526024810184905291169063a9059cbb906044016020604051808303816000875af1158015612989573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129ad91906139d0565b506005547501000000000000000000000000000000000000000000900460ff16156129da576129da612f62565b604080518d815260208101869052908101849052606081018c90526080810183905260a081018b905260c081018290524260e08201527f310a031bae0df2b1a8ba6de615833770c757a404a7395cc0121c13975e67c0b0906101000160405180910390a1505050505b5050505050505050505b600580547fffffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffff169055565b60055460009077010000000000000000000000000000000000000000000000900460ff16158015612ac2575060055474010000000000000000000000000000000000000000900460ff165b8015612acf575060285415155b8015612ae8575030600090815260208190526040812054115b8015610bfb5750612af833611886565b15905090565b6000610d418373ffffffffffffffffffffffffffffffffffffffff84166131ea565b6000610d4183836132dd565b73ffffffffffffffffffffffffffffffffffffffff811660009081526001830160205260408120541515610d41565b73ffffffffffffffffffffffffffffffffffffffff8316612bfe576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f64726573730000000000000000000000000000000000000000000000000000006064820152608401610bdc565b73ffffffffffffffffffffffffffffffffffffffff8216612ca1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f65737300000000000000000000000000000000000000000000000000000000006064820152608401610bdc565b73ffffffffffffffffffffffffffffffffffffffff831660009081526020819052604090205481811015612d57576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e636500000000000000000000000000000000000000000000000000006064820152608401610bdc565b73ffffffffffffffffffffffffffffffffffffffff848116600081815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3611c56565b600080601054600f5484612dde9190613a26565b612de89190613a3d565b9050612df5843083612b5b565b612dff81846139a4565b949350505050565b6000612e69826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166133079092919063ffffffff16565b8051909150156120365780806020019051810190612e8791906139d0565b612036576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610bdc565b6000818152600183016020526040812054612f5a57508154600181810184556000848152602080822090930184905584548482528286019093526040902091909155610ca6565b506000610ca6565b6040805160028082526060820183526000926020830190803683370190505090503081600081518110612f9757612f97613a78565b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff16815250507f00000000000000000000000000000000000000000000000000000000000000008160018151811061300557613005613a78565b73ffffffffffffffffffffffffffffffffffffffff9290921660209283029190910182015230600090815290819052604081205490613045600283613a3d565b90506103e881101561305657505050565b6040517f52aa4c22000000000000000000000000000000000000000000000000000000008152479060009073ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016906352aa4c22906130d790869085908a90309083904290600401613af8565b600060405180830381600087803b1580156130f157600080fd5b505af1925050508015613102575060015b6131ba576040517f791ac94700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000169063791ac947906131819086906000908a9030904290600401613b49565b600060405180830381600087803b15801561319b57600080fd5b505af19250505080156131ac575060015b156131b5575060015b6131be565b5060015b806131ca575050505050565b60006131d683476139a4565b90506131e28482613316565b505050505050565b600081815260018301602052604081205480156132d357600061320e6001836139a4565b8554909150600090613222906001906139a4565b905081811461328757600086600001828154811061324257613242613a78565b906000526020600020015490508087600001848154811061326557613265613a78565b6000918252602080832090910192909255918252600188019052604090208390555b855486908061329857613298613b92565b600190038181906000526020600020016000905590558560010160008681526020019081526020016000206000905560019350505050610ca6565b6000915050610ca6565b60008260000182815481106132f4576132f4613a78565b9060005260206000200154905092915050565b6060612dff848460008561347d565b613341307f0000000000000000000000000000000000000000000000000000000000000000846119d2565b6026546040517ff305d71900000000000000000000000000000000000000000000000000000000815230600482015260248101849052600060448201819052606482015273ffffffffffffffffffffffffffffffffffffffff91821660848201524260a48201527f00000000000000000000000000000000000000000000000000000000000000009091169063f305d71990839060c40160606040518083038185885af193505050508015613431575060408051601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016820190925261342e91810190613bc1565b60015b1561172e5750506040805184815260208101849052428183015290517ff75993dbe1645872cbbea6395e1feebee76b435baf0e4d62d7eac269c6f57b2492509081900360600190a15050565b60608247101561350f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610bdc565b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516135389190613a0a565b60006040518083038185875af1925050503d8060008114613575576040519150601f19603f3d011682016040523d82523d6000602084013e61357a565b606091505b509150915061358b87838387613596565b979650505050505050565b6060831561362c5782516000036136255773ffffffffffffffffffffffffffffffffffffffff85163b613625576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610bdc565b5081612dff565b612dff83838151156136415781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610bdc9190613699565b60005b83811015613690578181015183820152602001613678565b50506000910152565b60208152600082518060208401526136b8816040850160208701613675565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169190910160400192915050565b73ffffffffffffffffffffffffffffffffffffffff81168114610efc57600080fd5b6000806040838503121561371f57600080fd5b823561372a816136ea565b946020939093013593505050565b600080600080600080600060e0888a03121561375357600080fd5b505085359760208701359750604087013596606081013596506080810135955060a0810135945060c0013592509050565b60008060006060848603121561379957600080fd5b83356137a4816136ea565b925060208401356137b4816136ea565b929592945050506040919091013590565b6000602082840312156137d757600080fd5b8135610d41816136ea565b8015158114610efc57600080fd5b6000806040838503121561380357600080fd5b823561380e816136ea565b9150602083013561381e816137e2565b809150509250929050565b60006020828403121561383b57600080fd5b8135610d41816137e2565b60006020828403121561385857600080fd5b5035919050565b6000806040838503121561387257600080fd5b823561387d816136ea565b9150602083013561381e816136ea565b60008060008060008060c087890312156138a657600080fd5b86356138b1816136ea565b955060208701356138c1816136ea565b945060408701356138d1816136ea565b935060608701356138e1816136ea565b925060808701356138f1816136ea565b915060a0870135613901816136ea565b809150509295509295509295565b600181811c9082168061392357607f821691505b60208210810361395c577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b80820180821115610ca657610ca6613962565b81810381811115610ca657610ca6613962565b6000602082840312156139c957600080fd5b5051919050565b6000602082840312156139e257600080fd5b8151610d41816137e2565b6000602082840312156139ff57600080fd5b8151610d41816136ea565b60008251613a1c818460208701613675565b9190910192915050565b8082028115828204841417610ca657610ca6613962565b600082613a73577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600081518084526020808501945080840160005b83811015613aed57815173ffffffffffffffffffffffffffffffffffffffff1687529582019590820190600101613abb565b509495945050505050565b86815285602082015260c060408201526000613b1760c0830187613aa7565b73ffffffffffffffffffffffffffffffffffffffff958616606084015293909416608082015260a00152949350505050565b85815284602082015260a060408201526000613b6860a0830186613aa7565b73ffffffffffffffffffffffffffffffffffffffff94909416606083015250608001529392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b600080600060608486031215613bd657600080fd5b835192506020840151915060408401519050925092509256fea2646970667358221220224f730d37afe752fbc679fa5ba64f237e80b20b1113418fa90cd0a127c7f5f464736f6c63430008130033000000000000000000000000912ce59144191c1204e64559fe8253a0e49e65480000000000000000000000006eccab422d763ac031210895c81787e87b43a652000000000000000000000000c873fecbd354f5a56e00e710b90ef4201db2448d00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1

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

000000000000000000000000912ce59144191c1204e64559fe8253a0e49e65480000000000000000000000006eccab422d763ac031210895c81787e87b43a652000000000000000000000000c873fecbd354f5a56e00e710b90ef4201db2448d00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1

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

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

56881:14650:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68278:182;;;;;;;;;;;;;:::i;:::-;;57777:22;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;57777:22:0;;;;;;;;71201:98;;;;;;;;;;;;;:::i;6672:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;9023:201::-;;;;;;;;;;-1:-1:-1;9023:201:0;;;;;:::i;:::-;;:::i;:::-;;;1555:14:1;;1548:22;1530:41;;1518:2;1503:18;9023:201:0;1390:187:1;68468:598:0;;;;;;;;;;-1:-1:-1;68468:598:0;;;;;:::i;:::-;;:::i;58477:37::-;;;;;;;;;;;;;;;;58603:31;;;;;;;;;;;;;;;;58028;;;;;;;;;;;;;;;;57965:37;;;;;;;;;;;;;;;;7792:108;;;;;;;;;;-1:-1:-1;7880:12:0;;7792:108;;58360:32;;;;;;;;;;;;;;;;60535:269;;;;;;;;;;-1:-1:-1;60535:269:0;;;;;:::i;:::-;;:::i;68102:137::-;;;;;;;;;;;;;:::i;58807:29::-;;;;;;;;;;-1:-1:-1;58807:29:0;;;;;;;;;;;2833:42:1;2821:55;;;2803:74;;2791:2;2776:18;58807:29:0;2640:243:1;60278:92:0;;;;;;;;;;-1:-1:-1;60278:92:0;;60361:1;3030:36:1;;3018:2;3003:18;60278:92:0;2888:184:1;67959:135:0;;;;;;;;;;;;;:::i;10508:238::-;;;;;;;;;;-1:-1:-1;10508:238:0;;;;;:::i;:::-;;:::i;57600:43::-;;;;;;;;;;-1:-1:-1;57600:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;67513:172;;;;;;;;;;-1:-1:-1;67513:172:0;;;;;:::i;:::-;;:::i;60032:238::-;;;;;;;;;;;;;:::i;58641:34::-;;;;;;;;;;;;;;;;70159:119;;;;;;;;;;-1:-1:-1;70159:119:0;;;;;:::i;:::-;;:::i;58185:34::-;;;;;;;;;;;;;;;;57356:30;;;;;;;;;;-1:-1:-1;57356:30:0;;;;;;;;;;;7963:127;;;;;;;;;;-1:-1:-1;7963:127:0;;;;;:::i;:::-;8064:18;;8037:7;8064:18;;;;;;;;;;;;7963:127;58066:31;;;;;;;;;;;;;;;;36028:103;;;;;;;;;;;;;:::i;57650:59::-;;;;;;;;;;-1:-1:-1;57650:59:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;58142:36;;;;;;;;;;;;;;;;57393:38;;;;;;;;;;-1:-1:-1;57393:38:0;;;;;;;;;;;58908:23;;;;;;;;;;-1:-1:-1;58908:23:0;;;;;;;;58226:32;;;;;;;;;;;;;;;;35380:87;;;;;;;;;;-1:-1:-1;35453:6:0;;;;35380:87;;66461:68;;;;;;;;;;;;;:::i;69074:607::-;;;;;;;;;;-1:-1:-1;69074:607:0;;;;;:::i;:::-;;:::i;6891:104::-;;;;;;;;;;;;;:::i;70521:175::-;;;;;;;;;;-1:-1:-1;70521:175:0;;;;;:::i;:::-;;:::i;11249:436::-;;;;;;;;;;-1:-1:-1;11249:436:0;;;;;:::i;:::-;;:::i;71010:183::-;;;;;;;;;;-1:-1:-1;71010:183:0;;;;;:::i;:::-;;:::i;60378:149::-;;;;;;;;;;-1:-1:-1;60378:149:0;;;;;:::i;:::-;;:::i;70398:115::-;;;;;;;;;;-1:-1:-1;70398:115:0;;;;;:::i;:::-;;:::i;58563:33::-;;;;;;;;;;;;;;;;58438:32;;;;;;;;;;;;;;;;58521:35;;;;;;;;;;;;;;;;70286:104;;;;;;;;;;-1:-1:-1;70286:104:0;;;;;:::i;:::-;;:::i;71307:184::-;;;;;;;;;;-1:-1:-1;71307:184:0;;;;;:::i;:::-;;:::i;58938:25::-;;;;;;;;;;;;;;;;67693:258;;;;;;;;;;;;;:::i;70822:180::-;;;;;;;;;;-1:-1:-1;70822:180:0;;;;;:::i;:::-;;:::i;58970:34::-;;;;;;;;;;;;;;;;57748:22;;;;;;;;;;;;;;;;58265:30;;;;;;;;;;;;;;;;57478:18;;;;;;;;;;-1:-1:-1;57478:18:0;;;;;;;;;;;58399:32;;;;;;;;;;;;;;;;8552:151;;;;;;;;;;-1:-1:-1;8552:151:0;;;;;:::i;:::-;8668:18;;;;8641:7;8668:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8552:151;69689:462;;;;;;;;;;-1:-1:-1;69689:462:0;;;;;:::i;:::-;;:::i;58104:31::-;;;;;;;;;;;;;;;;70704:110;;;;;;;;;;-1:-1:-1;70704:110:0;;;;;:::i;:::-;;:::i;36286:201::-;;;;;;;;;;-1:-1:-1;36286:201:0;;;;;:::i;:::-;;:::i;58302:33::-;;;;;;;;;;;;;;;;57438:31;;;;;;;;;;-1:-1:-1;57438:31:0;;;;;;;;;;;68278:182;35266:13;:11;:13::i;:::-;68332:10:::1;::::0;:15;68324:44:::1;;;::::0;::::1;::::0;;6300:2:1;68324:44:0::1;::::0;::::1;6282:21:1::0;6339:2;6319:18;;;6312:30;6378:18;6358;;;6351:46;6414:18;;68324:44:0::1;;;;;;;;;68392:12;68379:10;:25:::0;68437:15:::1;68415:19;:37:::0;68278:182::o;71201:98::-;71249:7;71276:15;:6;:13;:15::i;:::-;71269:22;;71201:98;:::o;6672:100::-;6726:13;6759:5;6752:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6672:100;:::o;9023:201::-;9106:4;4398:10;9162:32;4398:10;9178:7;9187:6;9162:8;:32::i;:::-;9212:4;9205:11;;;9023:201;;;;;:::o;68468:598::-;35266:13;:11;:13::i;:::-;68722:10:::1;:21:::0;;;68754:10:::1;:21:::0;;;68786:15:::1;:31:::0;;;68828:13:::1;:27:::0;;;68866:11:::1;:23:::0;;;68900:9:::1;:19:::0;;;68930:10:::1;:21:::0;;;68943:8;68912:7;68880:9;68844:11;68804:13;68976:19:::1;68767:8:::0;68735;68976:19:::1;:::i;:::-;:35;;;;:::i;:::-;:49;;;;:::i;:::-;:61;;;;:::i;:::-;:71;;;;:::i;:::-;:82;;;;:::i;:::-;68962:11;:96:::0;-1:-1:-1;;;;;;;68468:598:0:o;60535:269::-;60641:4;4398:10;60699:40;60715:6;4398:10;60732:6;60699:15;:40::i;:::-;60757:39;60770:6;60778:9;60789:6;60757:12;:39::i;:::-;60750:46;;;60535:269;;;;;;:::o;68102:137::-;68155:7;8064:18;;;;;;59209:42;8064:18;;;;7880:12;;68182:31;;8064:18;68182:31;:::i;:::-;:49;;;;:::i;67959:135::-;35266:13;:11;:13::i;:::-;68018:9:::1;::::0;::::1;;:18;4398:10:::0;68051:9:::1;::::0;:34:::1;::::0;;;;68079:4:::1;68051:34;::::0;::::1;2803:74:1::0;68051:9:0::1;::::0;;::::1;::::0;:19:::1;::::0;2776:18:1;;68051:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68018:68;::::0;;::::1;::::0;;;;;;7730:42:1;7718:55;;;68018:68:0::1;::::0;::::1;7700:74:1::0;7790:18;;;7783:34;7673:18;;68018:68:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;67959:135::o:0;10508:238::-;4398:10;10596:4;8668:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;10596:4;;4398:10;10652:64;;4398:10;;8668:27;;10677:38;;10705:10;;10677:38;:::i;:::-;10652:8;:64::i;67513:172::-;35266:13;:11;:13::i;:::-;67631:45:::1;::::0;;;;67670:4:::1;67631:45;::::0;::::1;2803:74:1::0;67586:91:0::1;::::0;67620:10:::1;::::0;67631:30:::1;::::0;::::1;::::0;::::1;::::0;2776:18:1;;67631:45:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67586:33;::::0;::::1;::::0;:91;:33:::1;:91::i;60032:238::-:0;35266:13;:11;:13::i;:::-;60097:11:::1;::::0;::::1;;60096:12;60088:44;;;::::0;::::1;::::0;;8280:2:1;60088:44:0::1;::::0;::::1;8262:21:1::0;8319:2;8299:18;;;8292:30;8358:21;8338:18;;;8331:49;8397:18;;60088:44:0::1;8078:343:1::0;60088:44:0::1;60158:48;::::0;;;;:18:::1;60185:4;8679:15:1::0;;60158:48:0::1;::::0;::::1;8661:34:1::0;60200:4:0::1;8711:18:1::0;;;8704:43;-1:-1:-1;;60158:7:0::1;:18:::0;;::::1;::::0;::::1;::::0;8573::1;;60158:48:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60143:63:::0;-1:-1:-1;60217:16:0::1;:6;60143:63:::0;60217:10:::1;:16::i;:::-;-1:-1:-1::0;;60244:11:0::1;:18:::0;;;::::1;60258:4;60244:18;::::0;;60032:238::o;70159:119::-;35266:13;:11;:13::i;:::-;70242:19:::1;::::0;;;::::1;;::::0;;;:11:::1;:19;::::0;;;;:28;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;70159:119::o;36028:103::-;35266:13;:11;:13::i;:::-;36093:30:::1;36120:1;36093:18;:30::i;:::-;36028:103::o:0;66461:68::-;35266:13;:11;:13::i;:::-;66511:10:::1;:8;:10::i;69074:607::-:0;35266:13;:11;:13::i;:::-;69329:11:::1;:22:::0;;;69362:11:::1;:22:::0;;;69395:16:::1;:32:::0;;;69438:14:::1;:28:::0;;;69477:12:::1;:24:::0;;;69512:10:::1;:20:::0;;;69543:11:::1;:22:::0;;;69557:8;69525:7;69492:9;69455:11;69414:13;69591:19:::1;69376:8:::0;69343;69591:19:::1;:::i;:::-;:35;;;;:::i;:::-;:49;;;;:::i;:::-;:61;;;;:::i;:::-;:71;;;;:::i;:::-;:82;;;;:::i;:::-;69576:12;:97:::0;-1:-1:-1;;;;;;;69074:607:0:o;6891:104::-;6947:13;6980:7;6973:14;;;;;:::i;70521:175::-;35266:13;:11;:13::i;:::-;70600:16:::1;:14;:16::i;:::-;70599:17;70591:63;;;::::0;::::1;::::0;;9216:2:1;70591:63:0::1;::::0;::::1;9198:21:1::0;9255:2;9235:18;;;9228:30;9294:34;9274:18;;;9267:62;9365:3;9345:18;;;9338:31;9386:19;;70591:63:0::1;9014:397:1::0;70591:63:0::1;70665:12;:23:::0;;;::::1;;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;70521:175::o;11249:436::-;4398:10;11342:4;8668:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;11342:4;;4398:10;11489:15;11469:16;:35;;11461:85;;;;;;;9618:2:1;11461:85:0;;;9600:21:1;9657:2;9637:18;;;9630:30;9696:34;9676:18;;;9669:62;9767:7;9747:18;;;9740:35;9792:19;;11461:85:0;9416:401:1;11461:85:0;11582:60;11591:5;11598:7;11626:15;11607:16;:34;11582:8;:60::i;:::-;-1:-1:-1;11673:4:0;;11249:436;-1:-1:-1;;;;11249:436:0:o;71010:183::-;71067:4;35266:13;:11;:13::i;:::-;71092:18:::1;::::0;::::1;71084:64;;;::::0;::::1;::::0;;10024:2:1;71084:64:0::1;::::0;::::1;10006:21:1::0;10063:2;10043:18;;;10036:30;10102:34;10082:18;;;10075:62;10173:3;10153:18;;;10146:31;10194:19;;71084:64:0::1;9822:397:1::0;71084:64:0::1;71166:19;:6;71180:4:::0;71166:13:::1;:19::i;60378:149::-:0;60457:4;60481:38;4398:10;60508:2;60512:6;60481:12;:38::i;70398:115::-;35266:13;:11;:13::i;:::-;70475:19:::1;:30:::0;;;::::1;;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;70398:115::o;70286:104::-;35266:13;:11;:13::i;:::-;70360:11:::1;:22:::0;;;::::1;;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;70286:104::o;71307:184::-;71360:7;71415:1;71397:15;:6;:13;:15::i;:::-;:19;;;;:::i;:::-;71388:5;:28;;71380:69;;;;;;;10426:2:1;71380:69:0;;;10408:21:1;10465:2;10445:18;;;10438:30;10504;10484:18;;;10477:58;10552:18;;71380:69:0;10224:352:1;71380:69:0;71467:16;:6;71477:5;71467:9;:16::i;67693:258::-;35266:13;:11;:13::i;:::-;67871:12:::1;::::0;;67755:17:::1;67871:12:::0;;;::::1;::::0;::::1;::::0;;;;67775:21:::1;::::0;67755:17;;4398:10;;67775:21;;67826:58:::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67807:77;;;67903:7;67895:48;;;::::0;::::1;::::0;;11264:2:1;67895:48:0::1;::::0;::::1;11246:21:1::0;11303:2;11283:18;;;11276:30;11342;11322:18;;;11315:58;11390:18;;67895:48:0::1;11062:352:1::0;67895:48:0::1;67744:207;;67693:258::o:0;70822:180::-;70879:4;35266:13;:11;:13::i;:::-;70904:18:::1;::::0;::::1;70896:64;;;::::0;::::1;::::0;;10024:2:1;70896:64:0::1;::::0;::::1;10006:21:1::0;10063:2;10043:18;;;10036:30;10102:34;10082:18;;;10075:62;10173:3;10153:18;;;10146:31;10194:19;;70896:64:0::1;9822:397:1::0;70896:64:0::1;70978:16;:6;70989:4:::0;70978:10:::1;:16::i;69689:462::-:0;35266:13;:11;:13::i;:::-;69932:10:::1;:24:::0;;;;;::::1;;::::0;;::::1;;::::0;;;69967:10:::1;:24:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;70002:11:::1;:26:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;70039:13:::1;:40:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;70090:9:::1;:22:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;70123:8:::1;:20:::0;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;69689:462::o;70704:110::-;70758:4;70782:24;:6;70798:7;70782:15;:24::i;36286:201::-;35266:13;:11;:13::i;:::-;36375:22:::1;::::0;::::1;36367:73;;;::::0;::::1;::::0;;11621:2:1;36367:73:0::1;::::0;::::1;11603:21:1::0;11660:2;11640:18;;;11633:30;11699:34;11679:18;;;11672:62;11770:8;11750:18;;;11743:36;11796:19;;36367:73:0::1;11419:402:1::0;36367:73:0::1;36451:28;36470:8;36451:18;:28::i;35545:132::-:0;35453:6;;35609:23;35453:6;4398:10;35609:23;35601:68;;;;;;;12028:2:1;35601:68:0;;;12010:21:1;;;12047:18;;;12040:30;12106:34;12086:18;;;12079:62;12158:18;;35601:68:0;11826:356:1;46244:117:0;46307:7;46334:19;46342:3;41544:18;;41461:109;15276:380;15412:19;;;15404:68;;;;;;;12389:2:1;15404:68:0;;;12371:21:1;12428:2;12408:18;;;12401:30;12467:34;12447:18;;;12440:62;12538:6;12518:18;;;12511:34;12562:19;;15404:68:0;12187:400:1;15404:68:0;15491:21;;;15483:68;;;;;;;12794:2:1;15483:68:0;;;12776:21:1;12833:2;12813:18;;;12806:30;12872:34;12852:18;;;12845:62;12943:4;12923:18;;;12916:32;12965:19;;15483:68:0;12592:398:1;15483:68:0;15564:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;15616:32;;160:25:1;;;15616:32:0;;133:18:1;15616:32:0;;;;;;;15276:380;;;:::o;15947:453::-;8668:18;;;;16082:24;8668:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;16169:17;16149:37;;16145:248;;16231:6;16211:16;:26;;16203:68;;;;;;;13197:2:1;16203:68:0;;;13179:21:1;13236:2;13216:18;;;13209:30;13275:31;13255:18;;;13248:59;13324:18;;16203:68:0;12995:353:1;16203:68:0;16315:51;16324:5;16331:7;16359:6;16340:16;:25;16315:8;:51::i;:::-;16071:329;15947:453;;;:::o;60812:1374::-;60924:6;;60903:4;;60924:6;;;;;60920:101;;;60947:36;60957:6;60965:9;60976:6;60947:9;:36::i;:::-;-1:-1:-1;61005:4:0;60998:11;;60920:101;61036:35;;;;;;;:27;:35;;;;;;;;61031:112;;66604:10;;61088:43;;;;;;;13555:2:1;61088:43:0;;;13537:21:1;13594:2;13574:18;;;13567:30;13633:22;13613:18;;;13606:50;13673:18;;61088:43:0;13353:344:1;61088:43:0;61178:19;;;61155:18;61178:19;;;:11;:19;;;;;;;;61177:20;:47;;;;-1:-1:-1;61202:22:0;;;;;;;:11;:22;;;;;;;;61201:23;61177:47;61176:63;;;;-1:-1:-1;66604:10:0;;:15;;61229:10;61155:84;-1:-1:-1;61250:9:0;61290:6;61323:9;61368:14;61290:6;61368;:14::i;:::-;61364:353;;;61399:9;66684:10;;66674:7;:20;66715:10;;-1:-1:-1;66705:20:0;66746:10;;66736:7;:20;66782:15;;66767:12;:30;66821:13;;66808:10;:26;66856:11;;66845:8;:22;66887:9;;66878:6;:18;66918:11;;66907:8;:22;66635:302;61399:9;-1:-1:-1;;61511:13:0;;;:40;;;;;:13;7718:55:1;;;61511:40:0;;;7700:74:1;7790:18;;;7783:34;;;61430:1:0;;-1:-1:-1;61454:9:0;;61486:6;;61511:13;;:24;;7673:18:1;;61511:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61507:56;61364:353;61507:56;61364:353;;;61584:17;61591:9;61584:6;:17::i;:::-;61580:137;;;61618:10;66995:11;;66985:7;:21;67027:11;;67017:7;:21;67059:11;;67049:7;:21;67096:16;;67081:12;:31;67136:14;;67123:10;:27;67172:12;;-1:-1:-1;67161:23:0;67204:10;;-1:-1:-1;67195:19:0;67236:12;;-1:-1:-1;67225:23:0;66945:311;61618:10;61650:1;61643:8;;61580:137;;;61700:5;61684:21;;61580:137;61733:8;;61745:1;61733:13;61729:67;;61779:5;61763:21;;61729:67;61812:16;:14;:16::i;:::-;:33;;;;-1:-1:-1;61832:8:0;;:13;;61812:33;61808:76;;;61862:10;:8;:10::i;:::-;61896:22;61921:13;:48;;61963:6;61921:48;;;61937:23;61945:6;61953;61937:7;:23::i;:::-;61896:73;;61980:44;61990:6;61998:9;62009:14;61980:9;:44::i;:::-;62041:8;;62037:120;;62071:74;62077:5;62084;62091:6;62099:4;62105:22;:20;:22::i;:::-;62071:74;;;13999:42:1;14068:15;;;14050:34;;14120:15;;;;14115:2;14100:18;;14093:43;14152:18;;;14145:34;;;;14210:2;14195:18;;14188:34;14253:3;14238:19;;14231:35;62129:15:0;14297:3:1;14282:19;;14275:35;13976:3;13961:19;62071:74:0;;;;;;;62037:120;-1:-1:-1;62174:4:0;;60812:1374;-1:-1:-1;;;;;;;;60812:1374:0:o;30359:211::-;30503:58;;;7730:42:1;7718:55;;30503:58:0;;;7700:74:1;7790:18;;;;7783:34;;;30503:58:0;;;;;;;;;;7673:18:1;;;;30503:58:0;;;;;;;;;;30526:23;30503:58;;;30476:86;;30496:5;;30476:19;:86::i;:::-;30359:211;;;:::o;45419:152::-;45489:4;45513:50;45518:3;45538:23;;;45513:4;:50::i;36647:191::-;36740:6;;;;36757:17;;;;;;;;;;;36790:40;;36740:6;;;36757:17;36740:6;;36790:40;;36721:16;;36790:40;36710:128;36647:191;:::o;62376:2763::-;57534:6;:13;;;;;;;;62463:4:::1;-1:-1:-1::0;8064:18:0;;;;;;;;;;;62425:44:::1;;62480:55;62497:4;62512:10;62525:9;62480:8;:55::i;:::-;62548:21;62597:8;;62585:7;;62573:9;:19;;;;:::i;:::-;62572:34;;;;:::i;:::-;62548:58;;62617:19;62669:8;;62652:12;;62640:9;:24;;;;:::i;:::-;62639:39;;;;:::i;:::-;62617:61;;62689:22;62740:8;;62727;;62715:9;:20;;;;:::i;:::-;62714:35;;;;:::i;:::-;62689:60:::0;-1:-1:-1;62760:26:0::1;62773:13:::0;62760:26;::::1;:::i;:::-;::::0;-1:-1:-1;62797:24:0::1;62810:11:::0;62760:26;62797:24:::1;:::i;:::-;::::0;-1:-1:-1;62832:27:0::1;62845:14:::0;62797:24;62832:27:::1;:::i;:::-;62906:16;::::0;;62920:1:::1;62906:16:::0;;;;;::::1;::::0;;;62832:27;;-1:-1:-1;62882:21:0::1;::::0;62906:16;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;62906:16:0::1;62882:40;;62951:4;62933;62938:1;62933:7;;;;;;;;:::i;:::-;;;;;;:23;;;;;;;;;::::0;::::1;62985:4;62967;62972:1;62967:7;;;;;;;;:::i;:::-;:23;::::0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;63019:9:::1;::::0;63001:7;;63019:9;::::1;::::0;63001:4;;63006:1:::1;::::0;63001:7;::::1;;;;;:::i;:::-;:28;::::0;;::::1;:7;::::0;;::::1;::::0;;;;;:28;63097:9:::1;::::0;:34:::1;::::0;;;;63125:4:::1;63097:34;::::0;::::1;2803:74:1::0;63042:12:0::1;::::0;;;63097:9:::1;::::0;:19:::1;::::0;2776:18:1;;63097:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63146:123;::::0;;;;63073:58;;-1:-1:-1;63146:64:0::1;:10;:64;::::0;::::1;::::0;:123:::1;::::0;63211:9;;63221:1:::1;::::0;63223:4;;63236::::1;::::0;63221:1;;63253:15:::1;::::0;63146:123:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;63142:390;;63336:112;::::0;;;;:64:::1;:10;:64;::::0;::::1;::::0;:112:::1;::::0;63401:9;;63411:1:::1;::::0;63413:4;;63426::::1;::::0;63432:15:::1;::::0;63336:112:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;63332:189:::0;::::1;;63478:4;63468:14;;63332:189;63142:390;;;63294:4;63284:14;;63142:390;63547:7;63542:47;;63571:7;;;;;;;;;63542:47;63601:45;63619:4;59209:42;63632:13;63601:9;:45::i;:::-;63662:12;::::0;;;::::1;;;63657:269;;63716:11;::::0;63691:53:::1;::::0;63709:4:::1;::::0;63716:11:::1;;63729:14:::0;63691:9:::1;:53::i;:::-;63657:269;;;63813:11;::::0;63781:61:::1;::::0;63798:4:::1;::::0;63813:11:::1;;63827:14:::0;63781:8:::1;:61::i;:::-;63872:11;::::0;63857:57:::1;::::0;;;;::::1;::::0;::::1;160:25:1::0;;;63872:11:0::1;::::0;;::::1;::::0;63857:41:::1;::::0;133:18:1;;63857:57:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;63657:269;63973:9;::::0;:34:::1;::::0;;;;64001:4:::1;63973:34;::::0;::::1;2803:74:1::0;63947:23:0::1;::::0;64010:13;;63973:9:::1;::::0;;::::1;::::0;:19:::1;::::0;2776:18:1;;63973:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;;;:::i;:::-;63947:76;;64034:25;64098:8;;64083:12;;64073:7;;64062:8;;:18;;;;:::i;:::-;:33;;;;:::i;:::-;:44;;;;:::i;:::-;64034:72:::0;-1:-1:-1;64121:22:0;;64117:1004:::1;;64160:27;64221:17;64209:7;;64191:15;:25;;;;:::i;:::-;64190:49;;;;:::i;:::-;64160:79;;64254:27;64315:17;64303:7;;64285:15;:25;;;;:::i;:::-;64284:49;;;;:::i;:::-;64254:79;;64348:30;64414:17;64400:10;;64382:15;:28;;;;:::i;:::-;64381:50;;;;:::i;:::-;64348:83:::0;-1:-1:-1;64446:26:0::1;64348:83:::0;64515:19;64475:37:::1;64493:19:::0;64475:15;:37:::1;:::i;:::-;:59;;;;:::i;:::-;:84;;;;:::i;:::-;64576:9;::::0;64595:10:::1;::::0;64576:51:::1;::::0;;;;:9:::1;64595:10:::0;;::::1;64576:51;::::0;::::1;7700:74:1::0;7790:18;;;7783:34;;;64446:113:0;;-1:-1:-1;64576:9:0::1;::::0;:18:::1;::::0;7673::1;;64576:51:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;64642:9:0::1;::::0;64661:10:::1;::::0;64642:51:::1;::::0;;;;:9:::1;64661:10:::0;;::::1;64642:51;::::0;::::1;7700:74:1::0;7790:18;;;7783:34;;;64642:9:0;::::1;::::0;:18:::1;::::0;7673::1;;64642:51:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;64708:9:0::1;::::0;64735:13:::1;::::0;;64708:66:::1;::::0;;;;:9:::1;64735:13:::0;;::::1;64708:66;::::0;::::1;7700:74:1::0;7790:18;;;7783:34;;;64708:9:0;;::::1;::::0;:18:::1;::::0;7673::1;;64708:66:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;64789:9:0::1;::::0;64808::::1;::::0;64789:49:::1;::::0;;;;:9:::1;64808::::0;;::::1;64789:49;::::0;::::1;7700:74:1::0;7790:18;;;7783:34;;;64789:9:0;::::1;::::0;:18:::1;::::0;7673::1;;64789:49:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;64859:19:0::1;::::0;;;::::1;;;64855:70;;;64899:10;:8;:10::i;:::-;64954:155;::::0;;17116:25:1;;;17172:2;17157:18;;17150:34;;;17200:18;;;17193:34;;;17258:2;17243:18;;17236:34;;;17301:3;17286:19;;17279:35;;;17345:3;17330:19;;17323:35;;;17389:3;17374:19;;17367:35;;;65093:15:0::1;17433:3:1::0;17418:19;;17411:35;64954:155:0::1;::::0;17103:3:1;17088:19;64954:155:0::1;;;;;;;64145:976;;;;64117:1004;62414:2725;;;;;;;;;57558:1;57570:6:::0;:14;;;;;;62376:2763::o;62194:174::-;62268:6;;62243:4;;62268:6;;;;;62267:7;:22;;;;-1:-1:-1;62278:11:0;;;;;;;62267:22;:36;;;;-1:-1:-1;66604:10:0;;:15;;62293:10;62267:68;;;;-1:-1:-1;62325:4:0;62334:1;8064:18;;;;;;;;;;;62307:28;62267:68;:93;;;;-1:-1:-1;62340:20:0;4398:10;70704:110;:::i;62340:20::-;62339:21;62260:100;;62194:174;:::o;45747:158::-;45820:4;45844:53;45852:3;45872:23;;;45844:7;:53::i;46715:158::-;46789:7;46840:22;46844:3;46856:5;46840:3;:22::i;45991:167::-;46125:23;;;46071:4;41343:19;;;:12;;;:19;;;;;;:24;;46095:55;41246:129;12155:840;12286:18;;;12278:68;;;;;;;17659:2:1;12278:68:0;;;17641:21:1;17698:2;17678:18;;;17671:30;17737:34;17717:18;;;17710:62;17808:7;17788:18;;;17781:35;17833:19;;12278:68:0;17457:401:1;12278:68:0;12365:16;;;12357:64;;;;;;;18065:2:1;12357:64:0;;;18047:21:1;18104:2;18084:18;;;18077:30;18143:34;18123:18;;;18116:62;18214:5;18194:18;;;18187:33;18237:19;;12357:64:0;17863:399:1;12357:64:0;12507:15;;;12485:19;12507:15;;;;;;;;;;;12541:21;;;;12533:72;;;;;;;18469:2:1;12533:72:0;;;18451:21:1;18508:2;18488:18;;;18481:30;18547:34;18527:18;;;18520:62;18618:8;18598:18;;;18591:36;18644:19;;12533:72:0;18267:402:1;12533:72:0;12641:15;;;;:9;:15;;;;;;;;;;;12659:20;;;12641:38;;12859:13;;;;;;;;;;:23;;;;;;12911:26;;160:25:1;;;12859:13:0;;12911:26;;133:18:1;12911:26:0;;;;;;;12950:37;30359:211;67264:241;67331:7;67351:17;67393:14;;67381:8;;67372:6;:17;;;;:::i;:::-;67371:36;;;;:::i;:::-;67351:56;;67418:43;67428:6;67444:4;67451:9;67418;:43::i;:::-;67479:18;67488:9;67479:6;:18;:::i;:::-;67472:25;67264:241;-1:-1:-1;;;;67264:241:0:o;33426:716::-;33850:23;33876:69;33904:4;33876:69;;;;;;;;;;;;;;;;;33884:5;33876:27;;;;:69;;;;;:::i;:::-;33960:17;;33850:95;;-1:-1:-1;33960:21:0;33956:179;;34057:10;34046:30;;;;;;;;;;;;:::i;:::-;34038:85;;;;;;;18876:2:1;34038:85:0;;;18858:21:1;18915:2;18895:18;;;18888:30;18954:34;18934:18;;;18927:62;19025:12;19005:18;;;18998:40;19055:19;;34038:85:0;18674:406:1;39150:414:0;39213:4;41343:19;;;:12;;;:19;;;;;;39230:327;;-1:-1:-1;39273:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;39456:18;;39434:19;;;:12;;;:19;;;;;;:40;;;;39489:11;;39230:327;-1:-1:-1;39540:5:0;39533:12;;65147:936;65214:16;;;65228:1;65214:16;;;;;;;;65187:24;;65214:16;;;;;;;;;;-1:-1:-1;65214:16:0;65187:43;;65262:4;65241:7;65249:1;65241:10;;;;;;;;:::i;:::-;;;;;;:26;;;;;;;;;;;65299:4;65278:7;65286:1;65278:10;;;;;;;;:::i;:::-;:26;;;;;:10;;;;;;;;;;:26;65357:4;65317:19;8064:18;;;;;;;;;;;;65389:15;65403:1;8064:18;65389:15;:::i;:::-;65374:30;;65425:4;65418;:11;65415:23;;;65431:7;;;65147:936::o;65415:23::-;65543:119;;;;;65476:21;;65450:23;;65543:61;:10;:61;;;;:119;;65605:4;;65450:23;;65613:7;;65629:4;;65450:23;;65646:15;;65543:119;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65539:367;;65729:108;;;;;:61;:10;:61;;;;:108;;65791:4;;65796:1;;65799:7;;65815:4;;65821:15;;65729:108;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65725:170;;;-1:-1:-1;65866:4:0;65725:170;65539:367;;;-1:-1:-1;65687:4:0;65539:367;65921:7;65916:47;;65945:7;;;;;65147:936::o;65916:47::-;65975:17;65995:39;66019:15;65995:21;:39;:::i;:::-;65975:59;;66045:30;66059:4;66065:9;66045:13;:30::i;:::-;65176:907;;;;;;65147:936::o;39740:1420::-;39806:4;39945:19;;;:12;;;:19;;;;;;39981:15;;39977:1176;;40356:21;40380:14;40393:1;40380:10;:14;:::i;:::-;40429:18;;40356:38;;-1:-1:-1;40409:17:0;;40429:22;;40450:1;;40429:22;:::i;:::-;40409:42;;40485:13;40472:9;:26;40468:405;;40519:17;40539:3;:11;;40551:9;40539:22;;;;;;;;:::i;:::-;;;;;;;;;40519:42;;40693:9;40664:3;:11;;40676:13;40664:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;40778:23;;;:12;;;:23;;;;;:36;;;40468:405;40954:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;41049:3;:12;;:19;41062:5;41049:19;;;;;;;;;;;41042:26;;;41092:4;41085:11;;;;;;;39977:1176;41136:5;41129:12;;;;;41924:120;41991:7;42018:3;:11;;42030:5;42018:18;;;;;;;;:::i;:::-;;;;;;;;;42011:25;;41924:120;;;;:::o;24211:229::-;24348:12;24380:52;24402:6;24410:4;24416:1;24419:12;24380:21;:52::i;66091:362::-;66174:57;66191:4;66206:10;66219:11;66174:8;:57::i;:::-;66325:8;;66246:105;;;;;66299:4;66246:105;;;19638:34:1;19688:18;;;19681:34;;;66319:1:0;19731:18:1;;;19724:34;;;19774:18;;;19767:34;66246:26:0;66325:8;;;19817:19:1;;;19810:44;66335:15:0;19870:19:1;;;19863:35;66246:10:0;:26;;;;;;66280:9;;19549:19:1;;66246:105:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66246:105:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;66242:204;;;-1:-1:-1;;66372:53:0;;;20422:25:1;;;20478:2;20463:18;;20456:34;;;66409:15:0;20506:18:1;;;20499:34;66372:53:0;;;;-1:-1:-1;66372:53:0;;;;20410:2:1;66372:53:0;;;66091:362;;:::o;25331:455::-;25501:12;25559:5;25534:21;:30;;25526:81;;;;;;;20746:2:1;25526:81:0;;;20728:21:1;20785:2;20765:18;;;20758:30;20824:34;20804:18;;;20797:62;20895:8;20875:18;;;20868:36;20921:19;;25526:81:0;20544:402:1;25526:81:0;25619:12;25633:23;25660:6;:11;;25679:5;25686:4;25660:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25618:73;;;;25709:69;25736:6;25744:7;25753:10;25765:12;25709:26;:69::i;:::-;25702:76;25331:455;-1:-1:-1;;;;;;;25331:455:0:o;27904:644::-;28089:12;28118:7;28114:427;;;28146:10;:17;28167:1;28146:22;28142:290;;21749:19;;;;28356:60;;;;;;;21153:2:1;28356:60:0;;;21135:21:1;21192:2;21172:18;;;21165:30;21231:31;21211:18;;;21204:59;21280:18;;28356:60:0;20951:353:1;28356:60:0;-1:-1:-1;28453:10:0;28446:17;;28114:427;28496:33;28504:10;28516:12;29251:17;;:21;29247:388;;29483:10;29477:17;29540:15;29527:10;29523:2;29519:19;29512:44;29247:388;29610:12;29603:20;;;;;;;;;;;:::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:455::-;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;:::-;822:2;810:15;827:66;806:88;791:104;;;;897:2;787:113;;451:455;-1:-1:-1;;451:455:1:o;911:154::-;997:42;990:5;986:54;979:5;976:65;966:93;;1055:1;1052;1045:12;1070:315;1138:6;1146;1199:2;1187:9;1178:7;1174:23;1170:32;1167:52;;;1215:1;1212;1205:12;1167:52;1254:9;1241:23;1273:31;1298:5;1273:31;:::i;:::-;1323:5;1375:2;1360:18;;;;1347:32;;-1:-1:-1;;;1070:315:1:o;1582:592::-;1695:6;1703;1711;1719;1727;1735;1743;1796:3;1784:9;1775:7;1771:23;1767:33;1764:53;;;1813:1;1810;1803:12;1764:53;-1:-1:-1;;1836:23:1;;;1906:2;1891:18;;1878:32;;-1:-1:-1;1957:2:1;1942:18;;1929:32;;2008:2;1993:18;;1980:32;;-1:-1:-1;2059:3:1;2044:19;;2031:33;;-1:-1:-1;2111:3:1;2096:19;;2083:33;;-1:-1:-1;2163:3:1;2148:19;2135:33;;-1:-1:-1;1582:592:1;-1:-1:-1;1582:592:1:o;2179:456::-;2256:6;2264;2272;2325:2;2313:9;2304:7;2300:23;2296:32;2293:52;;;2341:1;2338;2331:12;2293:52;2380:9;2367:23;2399:31;2424:5;2399:31;:::i;:::-;2449:5;-1:-1:-1;2506:2:1;2491:18;;2478:32;2519:33;2478:32;2519:33;:::i;:::-;2179:456;;2571:7;;-1:-1:-1;;;2625:2:1;2610:18;;;;2597:32;;2179:456::o;3077:247::-;3136:6;3189:2;3177:9;3168:7;3164:23;3160:32;3157:52;;;3205:1;3202;3195:12;3157:52;3244:9;3231:23;3263:31;3288:5;3263:31;:::i;3329:118::-;3415:5;3408:13;3401:21;3394:5;3391:32;3381:60;;3437:1;3434;3427:12;3452:382;3517:6;3525;3578:2;3566:9;3557:7;3553:23;3549:32;3546:52;;;3594:1;3591;3584:12;3546:52;3633:9;3620:23;3652:31;3677:5;3652:31;:::i;:::-;3702:5;-1:-1:-1;3759:2:1;3744:18;;3731:32;3772:30;3731:32;3772:30;:::i;:::-;3821:7;3811:17;;;3452:382;;;;;:::o;4314:241::-;4370:6;4423:2;4411:9;4402:7;4398:23;4394:32;4391:52;;;4439:1;4436;4429:12;4391:52;4478:9;4465:23;4497:28;4519:5;4497:28;:::i;4560:180::-;4619:6;4672:2;4660:9;4651:7;4647:23;4643:32;4640:52;;;4688:1;4685;4678:12;4640:52;-1:-1:-1;4711:23:1;;4560:180;-1:-1:-1;4560:180:1:o;4745:388::-;4813:6;4821;4874:2;4862:9;4853:7;4849:23;4845:32;4842:52;;;4890:1;4887;4880:12;4842:52;4929:9;4916:23;4948:31;4973:5;4948:31;:::i;:::-;4998:5;-1:-1:-1;5055:2:1;5040:18;;5027:32;5068:33;5027:32;5068:33;:::i;5138:955::-;5242:6;5250;5258;5266;5274;5282;5335:3;5323:9;5314:7;5310:23;5306:33;5303:53;;;5352:1;5349;5342:12;5303:53;5391:9;5378:23;5410:31;5435:5;5410:31;:::i;:::-;5460:5;-1:-1:-1;5517:2:1;5502:18;;5489:32;5530:33;5489:32;5530:33;:::i;:::-;5582:7;-1:-1:-1;5641:2:1;5626:18;;5613:32;5654:33;5613:32;5654:33;:::i;:::-;5706:7;-1:-1:-1;5765:2:1;5750:18;;5737:32;5778:33;5737:32;5778:33;:::i;:::-;5830:7;-1:-1:-1;5889:3:1;5874:19;;5861:33;5903;5861;5903;:::i;:::-;5955:7;-1:-1:-1;6014:3:1;5999:19;;5986:33;6028;5986;6028;:::i;:::-;6080:7;6070:17;;;5138:955;;;;;;;;:::o;6443:437::-;6522:1;6518:12;;;;6565;;;6586:61;;6640:4;6632:6;6628:17;6618:27;;6586:61;6693:2;6685:6;6682:14;6662:18;6659:38;6656:218;;6730:77;6727:1;6720:88;6831:4;6828:1;6821:15;6859:4;6856:1;6849:15;6656:218;;6443:437;;;:::o;6885:184::-;6937:77;6934:1;6927:88;7034:4;7031:1;7024:15;7058:4;7055:1;7048:15;7074:125;7139:9;;;7160:10;;;7157:36;;;7173:18;;:::i;7204:128::-;7271:9;;;7292:11;;;7289:37;;;7306:18;;:::i;7337:184::-;7407:6;7460:2;7448:9;7439:7;7435:23;7431:32;7428:52;;;7476:1;7473;7466:12;7428:52;-1:-1:-1;7499:16:1;;7337:184;-1:-1:-1;7337:184:1:o;7828:245::-;7895:6;7948:2;7936:9;7927:7;7923:23;7919:32;7916:52;;;7964:1;7961;7954:12;7916:52;7996:9;7990:16;8015:28;8037:5;8015:28;:::i;8758:251::-;8828:6;8881:2;8869:9;8860:7;8856:23;8852:32;8849:52;;;8897:1;8894;8887:12;8849:52;8929:9;8923:16;8948:31;8973:5;8948:31;:::i;10770:287::-;10899:3;10937:6;10931:13;10953:66;11012:6;11007:3;11000:4;10992:6;10988:17;10953:66;:::i;:::-;11035:16;;;;;10770:287;-1:-1:-1;;10770:287:1:o;14321:168::-;14394:9;;;14425;;14442:15;;;14436:22;;14422:37;14412:71;;14463:18;;:::i;14494:274::-;14534:1;14560;14550:189;;14595:77;14592:1;14585:88;14696:4;14693:1;14686:15;14724:4;14721:1;14714:15;14550:189;-1:-1:-1;14753:9:1;;14494:274::o;14773:184::-;14825:77;14822:1;14815:88;14922:4;14919:1;14912:15;14946:4;14943:1;14936:15;14962:484;15015:3;15053:5;15047:12;15080:6;15075:3;15068:19;15106:4;15135:2;15130:3;15126:12;15119:19;;15172:2;15165:5;15161:14;15193:1;15203:218;15217:6;15214:1;15211:13;15203:218;;;15282:13;;15297:42;15278:62;15266:75;;15361:12;;;;15396:15;;;;15239:1;15232:9;15203:218;;;-1:-1:-1;15437:3:1;;14962:484;-1:-1:-1;;;;;14962:484:1:o;15451:707::-;15778:6;15767:9;15760:25;15821:6;15816:2;15805:9;15801:18;15794:34;15864:3;15859:2;15848:9;15844:18;15837:31;15741:4;15885:57;15937:3;15926:9;15922:19;15914:6;15885:57;:::i;:::-;15961:42;16039:15;;;16034:2;16019:18;;16012:43;16092:15;;;;16086:3;16071:19;;16064:44;16139:3;16124:19;16117:35;15877:65;15451:707;-1:-1:-1;;;;15451:707:1:o;16163:605::-;16462:6;16451:9;16444:25;16505:6;16500:2;16489:9;16485:18;16478:34;16548:3;16543:2;16532:9;16528:18;16521:31;16425:4;16569:57;16621:3;16610:9;16606:19;16598:6;16569:57;:::i;:::-;16674:42;16662:55;;;;16657:2;16642:18;;16635:83;-1:-1:-1;16749:3:1;16734:19;16727:35;16561:65;16163:605;-1:-1:-1;;;16163:605:1:o;19085:184::-;19137:77;19134:1;19127:88;19234:4;19231:1;19224:15;19258:4;19255:1;19248:15;19909:306;19997:6;20005;20013;20066:2;20054:9;20045:7;20041:23;20037:32;20034:52;;;20082:1;20079;20072:12;20034:52;20111:9;20105:16;20095:26;;20161:2;20150:9;20146:18;20140:25;20130:35;;20205:2;20194:9;20190:18;20184:25;20174:35;;19909:306;;;;;:::o

ipfs://224f730d37afe752fbc679fa5ba64f237e80b20b1113418fa90cd0a127c7f5f4