Contract 0xfce8595a467637ab901be1963962867c4cad3c0e

/**
 *Submitted for verification at cronoscan.com on 2023-03-17
*/

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


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

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


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

pragma solidity ^0.8.0;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

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


// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

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


// 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/access/AccessControl.sol


// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;





/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// 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/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: contracts/ImpToken.sol



pragma solidity ^0.8.0;





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

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

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

    function allPairs(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 setFeeToSetter(address) external;
}

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

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

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

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

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

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

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

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

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

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

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

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

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

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

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (
            uint112 reserve0,
            uint112 reserve1,
            uint32 blockTimestampLast
        );

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

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

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

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

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

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

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

    function WETH() external pure returns (address);

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

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

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

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

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

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

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

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

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

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

    function getAmountsIn(uint256 amountOut, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);
}

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

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

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

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

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

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


/**
 * @notice Anti-Bot Helper
 * Blacklis feature
 * Max TX Amount feature
 * Max Wallet Amount feature
 */
contract AntiBotHelper is Ownable {
    

    mapping(address => bool) internal _blacklist;

  


    /**
     * @notice Blacklist the account
     * @dev Only callable by owner
     */
    function blacklistAccount(address account, bool flag) external onlyOwner {
        _blacklist[account] = flag;
    }

    /**
     * @notice Check if the account is included in black list
     * @param account: the account to be checked
     */
    function blacklisted(address account) external view returns (bool) {
        return _blacklist[account];
    }

   
}

/**
 * @notice Tax Helper
 * Marketing fee
 * Burn fee
 * Fee in buy/sell/transfer separately
 */
contract FeeHelper is Ownable, AccessControl {
    bytes32 public constant ROLE_LAUNCHPAD = keccak256("LAUNCHPAD");
    enum TX_CASE {
        TRANSFER,
        BUY,
        SELL
    }

    struct TokenFee {
        uint16 marketingFee;
        uint16 treasuryFee;
        uint16 burnFee;
    }

    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
    address private constant ZERO = address(0);

    mapping(TX_CASE => TokenFee) internal _tokenFees;
    mapping(address => bool) internal _excludedFromTax;
    mapping(address => bool) internal _isSelfPair;

    constructor() {
        _excludedFromTax[_msgSender()] = true;
        _excludedFromTax[DEAD] = true;
        _excludedFromTax[ZERO] = true;
        _excludedFromTax[address(this)] = true;

        _tokenFees[TX_CASE.TRANSFER].marketingFee = 0;
        _tokenFees[TX_CASE.TRANSFER].treasuryFee = 0;
        _tokenFees[TX_CASE.TRANSFER].burnFee = 0;

        _tokenFees[TX_CASE.BUY].marketingFee = 0;
        _tokenFees[TX_CASE.BUY].treasuryFee = 100;
        _tokenFees[TX_CASE.BUY].burnFee = 0;

        _tokenFees[TX_CASE.SELL].marketingFee = 0;
        _tokenFees[TX_CASE.SELL].treasuryFee = 500;
        _tokenFees[TX_CASE.SELL].burnFee = 0;
    }

     modifier launchpad() {
    require(hasRole(ROLE_LAUNCHPAD, msg.sender) || msg.sender == owner(), "Only Launchpad and Admin can call this function");
    _;
}

    /**
     * @notice Update fee in the token
     * @param feeCase: which case the fee is for: transfer / buy / sell
     * @param marketingFee: fee percent for marketing
     * @param treasuryFee: fee percent for treasury
     * @param burnFee: fee percent for burning
     */
    function setFee(
        TX_CASE feeCase,
        uint16 marketingFee,
        uint16 treasuryFee,
        uint16 burnFee
    ) external onlyOwner {
        require(marketingFee + treasuryFee + burnFee <= 10000, "Overflow");
        _tokenFees[feeCase].marketingFee = marketingFee;
        _tokenFees[feeCase].treasuryFee = treasuryFee;
        _tokenFees[feeCase].burnFee = burnFee;
    }

    /**
     * @notice Exclude / Include the account from fee
     * @dev Only callable by owner
     */
    function excludeFromTax(address account, bool flag) external launchpad {
        _excludedFromTax[account] = flag;
    }

    /**
     * @notice Check if the account is excluded from the fees
     * @param account: the account to be checked
     */
    function excludedFromTax(address account) external view returns (bool) {
        return _excludedFromTax[account];
    }

    function viewFees(TX_CASE feeCase) external view returns (TokenFee memory) {
        return _tokenFees[feeCase];
    }

    /**
     * @notice Check if fee should be applied
     */
    function shouldFeeApplied(address from, address to)
        internal
        view
        returns (bool feeApplied, TX_CASE txCase)
    {
        // Sender or receiver is excluded from fee
        if (_excludedFromTax[from] || _excludedFromTax[to]) {
            feeApplied = false;
        }
        // Buying tokens
        else if (_isSelfPair[from]) {
            TokenFee memory buyFee = _tokenFees[TX_CASE.BUY];
            feeApplied =
                (buyFee.marketingFee + buyFee.treasuryFee + buyFee.burnFee) > 0;
            txCase = TX_CASE.BUY;
        }
        // Selling tokens
        else if (_isSelfPair[to]) {
            TokenFee memory sellFee = _tokenFees[TX_CASE.SELL];
            feeApplied =
                (sellFee.marketingFee + sellFee.treasuryFee + sellFee.burnFee) >
                0;
            txCase = TX_CASE.SELL;
        }
        // Transferring tokens
        else {
            TokenFee memory transferFee = _tokenFees[TX_CASE.TRANSFER];
            feeApplied =
                (transferFee.marketingFee +
                    transferFee.treasuryFee +
                    transferFee.burnFee) >
                0;
            txCase = TX_CASE.TRANSFER;
        }
    }

    /**
     * @notice Include / Exclude lp address in self pairs
     */
    function includeInSelfPair(address lpAddress, bool flag)
        external
        launchpad
    {
        _isSelfPair[lpAddress] = flag;
    }

    /**
     * @notice Check if the lp address is self pair
     */
    function isSelfPair(address lpAddress) external view returns (bool) {
        return _isSelfPair[lpAddress];
    }
}


contract ImpToken is AntiBotHelper, FeeHelper, ERC20 {

    

    address constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
    uint256 constant MAX_SUPPLY = 20e5 * 10e18; // 20,000,000,000



    address private _treasuryWallet ;

    bool private _inSwap;
    bool private _swapEnabled = false;
    uint256 private _thresholdAmount = 20 ether; // Threshold amount of accumlated tax until swap to marketing token
    IUniswapV2Router02 private _swapRouter;

    modifier lockTheSwap() {
        _inSwap = true;
        _;
        _inSwap = false;
    }


    constructor()
        ERC20("IMPERIVM", "IMP")
    {
        _treasuryWallet=msg.sender;
         _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        super._mint(_msgSender(), MAX_SUPPLY);
    }

   

    /**
     * @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 override {
        require(!_blacklist[from] && !_blacklist[to], "blacklisted account");
        require(amount > 0 , "you can't send 0");

    }

    function setSwapRouter(address newSwapRouter) external launchpad {
        require(newSwapRouter != address(0), "Invalid swap router");

        _swapRouter = IUniswapV2Router02(newSwapRouter);
    }

    function viewSwapRouter() external view returns (address) {
        return address(_swapRouter);
    }

    function enableSwap(bool flag) external launchpad {
        _swapEnabled = flag;
    }

    function swapEnabled() external view returns (bool) {
        return _swapEnabled;
    }

   
 function grantLaunchpadRole(address account) public {
        grantRole(ROLE_LAUNCHPAD, account);
    }


    function setTreasuryWallet(address wallet) external onlyOwner {
        require(wallet != address(0), "Invalid treasury wallet");
        _treasuryWallet = wallet;
    }

    function viewTreasuryWallet() external view returns (address) {
        return _treasuryWallet;
    }

    /**
     * @dev Set threshold amount to be swapped to the marketing token
     * Too small value will cause sell tx happens in every tx
     */
    function setThresholdAmount(uint256 amount) external onlyOwner {
        require(amount > 0, "Invalid threshold");
        _thresholdAmount = amount;
    }

    

    function viewThresholdAmount() external view returns (uint256) {
        return _thresholdAmount;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(amount > 0, "Zero transfer");

        // is the token balance of this contract address over the min number of
        // tokens that we need to initiate a swap + liquidity lock?
        // also, don't get caught in a circular liquidity event.
        // also, don't swap & liquify if sender is uniswap pair.
        uint256 contractTokenBalance = balanceOf(address(this));

        // indicates if fee should be deducted from transfer
        (bool feeApplied, TX_CASE txCase) = shouldFeeApplied(from, to);

        // Swap and liquify also triggered when the tx needs to have fee
        // This one will not work in case of token-buying, so we need to have another validation to check if it is not token-buying tx
        // by checking msg.sender not in candy pair
        if (
            !_inSwap &&
            feeApplied &&
            !_isSelfPair[from] &&
            _swapEnabled &&
            contractTokenBalance >= _thresholdAmount
        ) {
            _swapToMarketingToken(_thresholdAmount);
        }

        //transfer amount, it will take tax, burn fee
        _tokenTransfer(from, to, amount, feeApplied, txCase);
    }

    // this method is responsible for taking all fee, if takeFee is true
    function _tokenTransfer(
        address sender,
        address recipient,
        uint256 amount,
        bool feeApplied,
        TX_CASE txCase
    ) private {
        if (feeApplied) {
            uint16 treasuryFee = _tokenFees[txCase].treasuryFee;
            uint16 burnFee = _tokenFees[txCase].burnFee;

            uint256 burnFeeAmount = (amount * burnFee) / 10000;
            uint256 treasuryFeeAmount = (amount * treasuryFee) / 10000;

            if (burnFeeAmount > 0) {
                super._transfer(sender, BURN_ADDRESS, burnFeeAmount);
                amount -= burnFeeAmount;
            }
            if (treasuryFeeAmount > 0) {
                super._transfer(sender, _treasuryWallet, treasuryFeeAmount);
                amount -= treasuryFeeAmount;
            }
        }
        if (amount > 0) {
            super._transfer(sender, recipient, amount);
            _afterTokenTransfer(sender, recipient, amount);
        }
    }

    /**
     * @dev Swap token accumlated in this contract to the marketing token, ETH
     */
    function _swapToMarketingToken(uint256 amount) private lockTheSwap {
        // generate the uniswap pair path of token -> busd
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _swapRouter.WETH();

        _approve(address(this), address(_swapRouter), amount);

        // make the swap
        try
            _swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
                amount,
                0, 
                path,
                _treasuryWallet,
                block.timestamp + 300
            )
        {} catch (
            bytes memory /* lowLevelData */
        ) {}
    }


     // withdraw CRO if stuck or someone sends to the address
    function withdrawStuckCRO() external onlyOwner {
        bool success;
        (success,) = address(msg.sender).call{value: address(this).balance}("");
    }
}

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","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":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROLE_LAUNCHPAD","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"flag","type":"bool"}],"name":"blacklistAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"blacklisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"bool","name":"flag","type":"bool"}],"name":"enableSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"flag","type":"bool"}],"name":"excludeFromTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludedFromTax","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"grantLaunchpadRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"lpAddress","type":"address"},{"internalType":"bool","name":"flag","type":"bool"}],"name":"includeInSelfPair","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"address","name":"lpAddress","type":"address"}],"name":"isSelfPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum FeeHelper.TX_CASE","name":"feeCase","type":"uint8"},{"internalType":"uint16","name":"marketingFee","type":"uint16"},{"internalType":"uint16","name":"treasuryFee","type":"uint16"},{"internalType":"uint16","name":"burnFee","type":"uint16"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newSwapRouter","type":"address"}],"name":"setSwapRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setThresholdAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"setTreasuryWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"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":"from","type":"address"},{"internalType":"address","name":"to","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"},{"inputs":[{"internalType":"enum FeeHelper.TX_CASE","name":"feeCase","type":"uint8"}],"name":"viewFees","outputs":[{"components":[{"internalType":"uint16","name":"marketingFee","type":"uint16"},{"internalType":"uint16","name":"treasuryFee","type":"uint16"},{"internalType":"uint16","name":"burnFee","type":"uint16"}],"internalType":"struct FeeHelper.TokenFee","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewSwapRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewThresholdAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewTreasuryWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawStuckCRO","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

63946:6443:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63595:147;;;;;;:::i;:::-;;:::i;:::-;;27270:204;;;;;;:::i;:::-;;:::i;:::-;;;1091:14:1;;1084:22;1066:41;;1054:2;1039:18;27270:204:0;;;;;;;;35083:100;;;:::i;:::-;;;;;;;:::i;37434:201::-;;;;;;:::i;:::-;;:::i;36203:108::-;36291:12;;36203:108;;;2240:25:1;;;2228:2;2213:18;36203:108:0;2094:177:1;38215:295:0;;;;;;:::i;:::-;;:::i;29093:131::-;;;;;;:::i;:::-;29167:7;29194:12;;;:6;:12;;;;;:22;;;;29093:131;58932:118;;;;;;:::i;:::-;;:::i;29534:147::-;;;;;;:::i;:::-;;:::i;36045:93::-;;;36128:2;3566:36:1;;3554:2;3539:18;36045:93:0;3424:184:1;30678:218:0;;;;;;:::i;:::-;;:::i;65848:104::-;65932:11;;-1:-1:-1;;;;;65932:11:0;65848:104;;;-1:-1:-1;;;;;3777:32:1;;;3759:51;;3747:2;3732:18;65848:104:0;3613:203:1;38919:238:0;;;;;;:::i;:::-;;:::i;65637:203::-;;;;;;:::i;:::-;;:::i;63821:116::-;;;;;;:::i;:::-;-1:-1:-1;;;;;63907:22:0;63883:4;63907:22;;;:11;:22;;;;;;;;;63821:116;66888:105;66969:16;;66888:105;;59471:63;;-1:-1:-1;;;;;;;;;;;59471:63:0;;66156:105;;;;;;:::i;:::-;;:::i;66056:90::-;66126:12;;-1:-1:-1;;;66126:12:0;;;;66056:90;;36374:127;;;;;;:::i;:::-;-1:-1:-1;;;;;36475:18:0;36448:7;36475:18;;;:9;:18;;;;;;;36374:127;48154:103;;;:::i;61163:399::-;;;;;;:::i;:::-;;:::i;47506:87::-;47552:7;47579:6;-1:-1:-1;;;;;47579:6:0;47506:87;;27566:147;;;;;;:::i;:::-;;:::i;35302:104::-;;;:::i;66714:158::-;;;;;;:::i;:::-;;:::i;61940:122::-;;;;;;:::i;:::-;-1:-1:-1;;;;;62029:25:0;62005:4;62029:25;;;:16;:25;;;;;;;;;61940:122;26671:49;;26716:4;26671:49;;39660:436;;;;;;:::i;:::-;;:::i;66271:172::-;;;;;;:::i;:::-;;:::i;36707:193::-;;;;;;:::i;:::-;;:::i;62070:120::-;;;;;;:::i;:::-;;:::i;:::-;;;;5453:13:1;;5416:6;5449:22;;;5431:41;;5532:4;5520:17;;;5514:24;5510:33;;5488:20;;;5481:63;5592:17;;;5586:24;5582:33;;;5560:20;;;5553:63;5394:2;5379:18;62070:120:0;5208:414:1;61679:122:0;;;;;;:::i;:::-;;:::i;66451:103::-;66531:15;;-1:-1:-1;;;;;66531:15:0;66451:103;;65960:88;;;;;;:::i;:::-;;:::i;29974:149::-;;;;;;:::i;:::-;;:::i;59189:112::-;;;;;;:::i;:::-;-1:-1:-1;;;;;59274:19:0;59250:4;59274:19;;;:10;:19;;;;;;;;;59189:112;70226:160;;;:::i;36963:151::-;;;;;;:::i;:::-;;:::i;48412:201::-;;;;;;:::i;:::-;;:::i;63595:147::-;60744:35;-1:-1:-1;;;;;;;;;;;60768:10:0;60744:7;:35::i;:::-;:60;;;-1:-1:-1;47552:7:0;47579:6;-1:-1:-1;;;;;47579:6:0;60783:10;:21;60744:60;60736:120;;;;-1:-1:-1;;;60736:120:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;63705:22:0;;;::::1;;::::0;;;:11:::1;:22;::::0;;;;:29;;-1:-1:-1;;63705:29:0::1;::::0;::::1;;::::0;;;::::1;::::0;;63595:147::o;27270:204::-;27355:4;-1:-1:-1;;;;;;27379:47:0;;-1:-1:-1;;;27379:47:0;;:87;;-1:-1:-1;;;;;;;;;;1891:40:0;;;27430:36;27372:94;27270:204;-1:-1:-1;;27270:204:0:o;35083:100::-;35137:13;35170:5;35163:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35083:100;:::o;37434:201::-;37517:4;24559:10;37573:32;24559:10;37589:7;37598:6;37573:8;:32::i;:::-;-1:-1:-1;37623:4:0;;37434:201;-1:-1:-1;;;37434:201:0:o;38215:295::-;38346:4;24559:10;38404:38;38420:4;24559:10;38435:6;38404:15;:38::i;:::-;38453:27;38463:4;38469:2;38473:6;38453:9;:27::i;:::-;-1:-1:-1;38498:4:0;;38215:295;-1:-1:-1;;;;38215:295:0:o;58932:118::-;47392:13;:11;:13::i;:::-;-1:-1:-1;;;;;59016:19:0;;;::::1;;::::0;;;:10:::1;:19;::::0;;;;:26;;-1:-1:-1;;59016:26:0::1;::::0;::::1;;::::0;;;::::1;::::0;;58932:118::o;29534:147::-;29167:7;29194:12;;;:6;:12;;;;;:22;;;27162:16;27173:4;27162:10;:16::i;:::-;29648:25:::1;29659:4;29665:7;29648:10;:25::i;:::-;29534:147:::0;;;:::o;30678:218::-;-1:-1:-1;;;;;30774:23:0;;24559:10;30774:23;30766:83;;;;-1:-1:-1;;;30766:83:0;;7208:2:1;30766:83:0;;;7190:21:1;7247:2;7227:18;;;7220:30;7286:34;7266:18;;;7259:62;-1:-1:-1;;;7337:18:1;;;7330:45;7392:19;;30766:83:0;7006:411:1;30766:83:0;30862:26;30874:4;30880:7;30862:11;:26::i;:::-;30678:218;;:::o;38919:238::-;39007:4;24559:10;39063:64;24559:10;39079:7;39116:10;39088:25;24559:10;39079:7;39088:9;:25::i;:::-;:38;;;;:::i;:::-;39063:8;:64::i;65637:203::-;60744:35;-1:-1:-1;;;;;;;;;;;60768:10:0;60744:7;:35::i;:::-;:60;;;-1:-1:-1;47552:7:0;47579:6;-1:-1:-1;;;;;47579:6:0;60783:10;:21;60744:60;60736:120;;;;-1:-1:-1;;;60736:120:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;65721:27:0;::::1;65713:59;;;::::0;-1:-1:-1;;;65713:59:0;;7886:2:1;65713:59:0::1;::::0;::::1;7868:21:1::0;7925:2;7905:18;;;7898:30;-1:-1:-1;;;7944:18:1;;;7937:49;8003:18;;65713:59:0::1;7684:343:1::0;65713:59:0::1;65785:11;:47:::0;;-1:-1:-1;;;;;;65785:47:0::1;-1:-1:-1::0;;;;;65785:47:0;;;::::1;::::0;;;::::1;::::0;;65637:203::o;66156:105::-;66219:34;-1:-1:-1;;;;;;;;;;;66245:7:0;66219:9;:34::i;:::-;66156:105;:::o;48154:103::-;47392:13;:11;:13::i;:::-;48219:30:::1;48246:1;48219:18;:30::i;:::-;48154:103::o:0;61163:399::-;47392:13;:11;:13::i;:::-;61374:5:::1;61363:7:::0;61334:26:::1;61349:11:::0;61334:12;:26:::1;:::i;:::-;:36;;;;:::i;:::-;:45;;;;61326:66;;;::::0;-1:-1:-1;;;61326:66:0;;8407:2:1;61326:66:0::1;::::0;::::1;8389:21:1::0;8446:1;8426:18;;;8419:29;-1:-1:-1;;;8464:18:1;;;8457:38;8512:18;;61326:66:0::1;8205:331:1::0;61326:66:0::1;61438:12;61403:10;:19;61414:7;61403:19;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:32;;;:47;;;;;;;;;;;;;;;;;;61495:11;61461:10;:19;61472:7;61461:19;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:31;;;:45;;;;;;;;;;;;;;;;;;61547:7;61517:10;:19;61528:7;61517:19;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:27;;;:37;;;;;;;;;;;;;;;;;;61163:399:::0;;;;:::o;27566:147::-;27652:4;27676:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;27676:29:0;;;;;;;;;;;;;;;27566:147::o;35302:104::-;35358:13;35391:7;35384:14;;;;;:::i;66714:158::-;47392:13;:11;:13::i;:::-;66805:1:::1;66796:6;:10;66788:40;;;::::0;-1:-1:-1;;;66788:40:0;;8875:2:1;66788:40:0::1;::::0;::::1;8857:21:1::0;8914:2;8894:18;;;8887:30;-1:-1:-1;;;8933:18:1;;;8926:47;8990:18;;66788:40:0::1;8673:341:1::0;66788:40:0::1;66839:16;:25:::0;66714:158::o;39660:436::-;39753:4;24559:10;39753:4;39836:25;24559:10;39853:7;39836:9;:25::i;:::-;39809:52;;39900:15;39880:16;:35;;39872:85;;;;-1:-1:-1;;;39872:85:0;;9221:2:1;39872:85:0;;;9203:21:1;9260:2;9240:18;;;9233:30;9299:34;9279:18;;;9272:62;-1:-1:-1;;;9350:18:1;;;9343:35;9395:19;;39872:85:0;9019:401:1;39872:85:0;39993:60;40002:5;40009:7;40037:15;40018:16;:34;39993:8;:60::i;66271:172::-;47392:13;:11;:13::i;:::-;-1:-1:-1;;;;;66352:20:0;::::1;66344:56;;;::::0;-1:-1:-1;;;66344:56:0;;9627:2:1;66344:56:0::1;::::0;::::1;9609:21:1::0;9666:2;9646:18;;;9639:30;9705:25;9685:18;;;9678:53;9748:18;;66344:56:0::1;9425:347:1::0;66344:56:0::1;66411:15;:24:::0;;-1:-1:-1;;;;;;66411:24:0::1;-1:-1:-1::0;;;;;66411:24:0;;;::::1;::::0;;;::::1;::::0;;66271:172::o;36707:193::-;36786:4;24559:10;36842:28;24559:10;36859:2;36863:6;36842:9;:28::i;62070:120::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;62163:10:0;:19;62174:7;62163:19;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;62163:19:0;62156:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62070:120;-1:-1:-1;;62070:120:0:o;61679:122::-;60744:35;-1:-1:-1;;;;;;;;;;;60768:10:0;60744:7;:35::i;:::-;:60;;;-1:-1:-1;47552:7:0;47579:6;-1:-1:-1;;;;;47579:6:0;60783:10;:21;60744:60;60736:120;;;;-1:-1:-1;;;60736:120:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;61761:25:0;;;::::1;;::::0;;;:16:::1;:25;::::0;;;;:32;;-1:-1:-1;;61761:32:0::1;::::0;::::1;;::::0;;;::::1;::::0;;61679:122::o;65960:88::-;60744:35;-1:-1:-1;;;;;;;;;;;60768:10:0;60744:7;:35::i;:::-;:60;;;-1:-1:-1;47552:7:0;47579:6;-1:-1:-1;;;;;47579:6:0;60783:10;:21;60744:60;60736:120;;;;-1:-1:-1;;;60736:120:0;;;;;;;:::i;:::-;66021:12:::1;:19:::0;;;::::1;;-1:-1:-1::0;;;66021:19:0::1;-1:-1:-1::0;;;;66021:19:0;;::::1;::::0;;;::::1;::::0;;65960:88::o;29974:149::-;29167:7;29194:12;;;:6;:12;;;;;:22;;;27162:16;27173:4;27162:10;:16::i;:::-;30089:26:::1;30101:4;30107:7;30089:11;:26::i;70226:160::-:0;47392:13;:11;:13::i;:::-;70320:58:::1;::::0;70284:12:::1;::::0;70328:10:::1;::::0;70352:21:::1;::::0;70284:12;70320:58;70284:12;70320:58;70352:21;70328:10;70320:58:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;70226:160:0:o;36963:151::-;-1:-1:-1;;;;;37079:18:0;;;37052:7;37079:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;36963:151::o;48412:201::-;47392:13;:11;:13::i;:::-;-1:-1:-1;;;;;48501:22:0;::::1;48493:73;;;::::0;-1:-1:-1;;;48493:73:0;;10189:2:1;48493:73:0::1;::::0;::::1;10171:21:1::0;10228:2;10208:18;;;10201:30;10267:34;10247:18;;;10240:62;-1:-1:-1;;;10318:18:1;;;10311:36;10364:19;;48493:73:0::1;9987:402:1::0;48493:73:0::1;48577:28;48596:8;48577:18;:28::i;41693:548::-:0;-1:-1:-1;;;;;41777:21:0;;41769:65;;;;-1:-1:-1;;;41769:65:0;;10596:2:1;41769:65:0;;;10578:21:1;10635:2;10615:18;;;10608:30;10674:33;10654:18;;;10647:61;10725:18;;41769:65:0;10394:355:1;41769:65:0;41925:6;41909:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;42080:18:0;;;;;;:9;:18;;;;;;;;:28;;;;;;42135:37;2240:25:1;;;42135:37:0;;2213:18:1;42135:37:0;;;;;;;42185:48;42213:1;42217:7;42226:6;42185:19;:48::i;43687:380::-;-1:-1:-1;;;;;43823:19:0;;43815:68;;;;-1:-1:-1;;;43815:68:0;;10956:2:1;43815:68:0;;;10938:21:1;10995:2;10975:18;;;10968:30;11034:34;11014:18;;;11007:62;-1:-1:-1;;;11085:18:1;;;11078:34;11129:19;;43815:68:0;10754:400:1;43815:68:0;-1:-1:-1;;;;;43902:21:0;;43894:68;;;;-1:-1:-1;;;43894:68:0;;11361:2:1;43894:68:0;;;11343:21:1;11400:2;11380:18;;;11373:30;11439:34;11419:18;;;11412:62;-1:-1:-1;;;11490:18:1;;;11483:32;11532:19;;43894:68:0;11159:398:1;43894:68:0;-1:-1:-1;;;;;43975:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;44027:32;;2240:25:1;;;44027:32:0;;2213:18:1;44027:32:0;;;;;;;43687:380;;;:::o;44358:453::-;44493:24;44520:25;44530:5;44537:7;44520:9;:25::i;:::-;44493:52;;-1:-1:-1;;44560:16:0;:37;44556:248;;44642:6;44622:16;:26;;44614:68;;;;-1:-1:-1;;;44614:68:0;;11764:2:1;44614:68:0;;;11746:21:1;11803:2;11783:18;;;11776:30;11842:31;11822:18;;;11815:59;11891:18;;44614:68:0;11562:353:1;44614:68:0;44726:51;44735:5;44742:7;44770:6;44751:16;:25;44726:8;:51::i;67001:1302::-;67142:1;67133:6;:10;67125:36;;;;-1:-1:-1;;;67125:36:0;;12122:2:1;67125:36:0;;;12104:21:1;12161:2;12141:18;;;12134:30;-1:-1:-1;;;12180:18:1;;;12173:43;12233:18;;67125:36:0;11920:337:1;67125:36:0;67505:4;67456:28;36475:18;;;:9;:18;;;;;;;67456:28;67622:26;67639:4;67645:2;67622:16;:26::i;:::-;67943:7;;67586:62;;-1:-1:-1;67586:62:0;-1:-1:-1;;;;67943:7:0;;;;67942:8;:35;;;;;67967:10;67942:35;:70;;;;-1:-1:-1;;;;;;67995:17:0;;;;;;:11;:17;;;;;;;;67994:18;67942:70;:99;;;;-1:-1:-1;68029:12:0;;-1:-1:-1;;;68029:12:0;;;;67942:99;:156;;;;;68082:16;;68058:20;:40;;67942:156;67924:252;;;68125:39;68147:16;;68125:21;:39::i;:::-;68243:52;68258:4;68264:2;68268:6;68276:10;68288:6;68243:14;:52::i;:::-;67114:1189;;;67001:1302;;;:::o;47671:132::-;47552:7;47579:6;-1:-1:-1;;;;;47579:6:0;24559:10;47735:23;47727:68;;;;-1:-1:-1;;;47727:68:0;;12464:2:1;47727:68:0;;;12446:21:1;;;12483:18;;;12476:30;12542:34;12522:18;;;12515:62;12594:18;;47727:68:0;12262:356:1;28017:105:0;28084:30;28095:4;24559:10;28084;:30::i;32275:238::-;32359:22;32367:4;32373:7;32359;:22::i;:::-;32354:152;;32398:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;32398:29:0;;;;;;;;;:36;;-1:-1:-1;;32398:36:0;32430:4;32398:36;;;32481:12;24559:10;;24479:98;32481:12;-1:-1:-1;;;;;32454:40:0;32472:7;-1:-1:-1;;;;;32454:40:0;32466:4;32454:40;;;;;;;;;;32275:238;;:::o;32693:239::-;32777:22;32785:4;32791:7;32777;:22::i;:::-;32773:152;;;32848:5;32816:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;32816:29:0;;;;;;;;;;:37;;-1:-1:-1;;32816:37:0;;;32873:40;24559:10;;32816:12;;32873:40;;32848:5;32873:40;32693:239;;:::o;48773:191::-;48847:16;48866:6;;-1:-1:-1;;;;;48883:17:0;;;-1:-1:-1;;;;;;48883:17:0;;;;;;48916:40;;48866:6;;;;;;;48916:40;;48847:16;48916:40;48836:128;48773:191;:::o;65358:271::-;-1:-1:-1;;;;;65509:16:0;;;;;;:10;:16;;;;;;;;65508:17;:36;;;;-1:-1:-1;;;;;;65530:14:0;;;;;;:10;:14;;;;;;;;65529:15;65508:36;65500:68;;;;-1:-1:-1;;;65500:68:0;;12825:2:1;65500:68:0;;;12807:21:1;12864:2;12844:18;;;12837:30;-1:-1:-1;;;12883:18:1;;;12876:49;12942:18;;65500:68:0;12623:343:1;65500:68:0;65596:1;65587:6;:10;65579:40;;;;-1:-1:-1;;;65579:40:0;;13173:2:1;65579:40:0;;;13155:21:1;13212:2;13192:18;;;13185:30;-1:-1:-1;;;13231:18:1;;;13224:46;13287:18;;65579:40:0;12971:340:1;62263:1247:0;-1:-1:-1;;;;;62470:22:0;;62365:15;62470:22;;;:16;:22;;;;;;62365:15;;62470:22;;;:46;;-1:-1:-1;;;;;;62496:20:0;;;;;;:16;:20;;;;;;;;62470:46;62466:1037;;;62546:5;62533:18;;62466:1037;;;-1:-1:-1;;;;;62608:17:0;;;;;;:11;:17;;;;;;;;62604:899;;;62678:11;62642:22;62667:23;;;:10;:23;;;;;62642:48;;;;;;;62667:23;62642:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:22;62736:40;;;:::i;:::-;:57;;;;:::i;:::-;62735:63;;;62705:93;;62822:11;62813:20;;62627:218;62604:899;;;-1:-1:-1;;;;;62891:15:0;;;;;;:11;:15;;;;;;;;62887:616;;;62960:12;62923:23;62949:24;;;:10;:24;;;;;62923:50;;;;;;;62949:24;62923:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:23;63019:42;;;:::i;:::-;:60;;;;:::i;:::-;63018:83;;;62988:113;;63125:12;63116:21;;62908:241;62887:616;;;63211:27;63241:28;;;:10;:28;;;;;63211:58;;;;;;;63241:28;63211:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:27;63315:71;;;:::i;:::-;:114;;;;:::i;:::-;63314:137;;;63284:167;;63475:16;63466:25;;63196:307;62887:616;62263:1247;;;;;:::o;69474:679::-;64477:7;:14;;-1:-1:-1;;;;64477:14:0;-1:-1:-1;;;64477:14:0;;;69636:16:::1;::::0;;69650:1:::1;69636:16:::0;;;;;::::1;::::0;;-1:-1:-1;;69636:16:0::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;69636:16:0::1;69612:40;;69681:4;69663;69668:1;69663:7;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;69663:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;;:23;;;;69707:11:::1;::::0;:18:::1;::::0;;-1:-1:-1;;;69707:18:0;;;;:11;;;::::1;::::0;:16:::1;::::0;:18:::1;::::0;;::::1;::::0;69663:7;;69707:18;;;;;:11;:18:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;69697:4;69702:1;69697:7;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;69697:28:0;;::::1;:7;::::0;;::::1;::::0;;;;;:28;69770:11:::1;::::0;69738:53:::1;::::0;69755:4:::1;::::0;69770:11:::1;69784:6:::0;69738:8:::1;:53::i;:::-;69847:11;::::0;69997:15:::1;::::0;-1:-1:-1;;;;;69847:11:0;;::::1;::::0;:62:::1;::::0;69928:6;;69847:11:::1;::::0;69974:4;;69997:15:::1;70031:21;:15;70049:3;70031:21;:::i;:::-;69847:220;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;69830:316;;;::::0;;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70080:66;69830:316;-1:-1:-1::0;;64514:7:0;:15;;-1:-1:-1;;;;64514:15:0;;;69474:679::o;68385:983::-;68568:10;68564:641;;;68595:18;68616:10;:18;68627:6;68616:18;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;68616:18:0;;;:30;;;;;;;-1:-1:-1;68678:10:0;-1:-1:-1;68689:6:0;68616:30;68678:18;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;68678:18:0;;;:26;;;;;;;-1:-1:-1;68766:5:0;68746:16;68678:26;68746:6;:16;:::i;:::-;68745:26;;;;:::i;:::-;68721:50;-1:-1:-1;68786:25:0;68839:5;68815:20;;;;:6;:20;:::i;:::-;68814:30;;;;:::i;:::-;68786:58;-1:-1:-1;68865:17:0;;68861:152;;68903:52;68919:6;64048:42;68941:13;68903:15;:52::i;:::-;68974:23;68984:13;68974:23;;:::i;:::-;;;68861:152;69031:21;;69027:167;;69097:15;;69073:59;;69089:6;;-1:-1:-1;;;;;69097:15:0;69114:17;69073:15;:59::i;:::-;69151:27;69161:17;69151:27;;:::i;:::-;;;69027:167;68580:625;;;;68564:641;69219:10;;69215:146;;69246:42;69262:6;69270:9;69281:6;69246:15;:42::i;:::-;69303:46;69323:6;69331:9;69342:6;69303:19;:46::i;:::-;68385:983;;;;;:::o;28412:492::-;28501:22;28509:4;28515:7;28501;:22::i;:::-;28496:401;;28689:28;28709:7;28689:19;:28::i;:::-;28790:38;28818:4;28825:2;28790:19;:38::i;:::-;28594:257;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;28594:257:0;;;;;;;;;;-1:-1:-1;;;28540:345:0;;;;;;;:::i;40566:840::-;-1:-1:-1;;;;;40697:18:0;;40689:68;;;;-1:-1:-1;;;40689:68:0;;16368:2:1;40689:68:0;;;16350:21:1;16407:2;16387:18;;;16380:30;16446:34;16426:18;;;16419:62;-1:-1:-1;;;16497:18:1;;;16490:35;16542:19;;40689:68:0;16166:401:1;40689:68:0;-1:-1:-1;;;;;40776:16:0;;40768:64;;;;-1:-1:-1;;;40768:64:0;;16774:2:1;40768:64:0;;;16756:21:1;16813:2;16793:18;;;16786:30;16852:34;16832:18;;;16825:62;-1:-1:-1;;;16903:18:1;;;16896:33;16946:19;;40768:64:0;16572:399:1;40768:64:0;-1:-1:-1;;;;;40918:15:0;;40896:19;40918:15;;;:9;:15;;;;;;40952:21;;;;40944:72;;;;-1:-1:-1;;;40944:72:0;;17178:2:1;40944:72:0;;;17160:21:1;17217:2;17197:18;;;17190:30;17256:34;17236:18;;;17229:62;-1:-1:-1;;;17307:18:1;;;17300:36;17353:19;;40944:72:0;16976:402:1;40944:72:0;-1:-1:-1;;;;;41052:15:0;;;;;;;:9;:15;;;;;;41070:20;;;41052:38;;41270:13;;;;;;;;;;:23;;;;;;41322:26;;;;;;41084:6;2240:25:1;;2228:2;2213:18;;2094:177;41322:26:0;;;;;;;;41361:37;41381:4;41387:2;41391:6;41361:19;:37::i;16987:151::-;17045:13;17078:52;-1:-1:-1;;;;;17090:22:0;;15142:2;16383:447;16458:13;16484:19;16516:10;16520:6;16516:1;:10;:::i;:::-;:14;;16529:1;16516:14;:::i;:::-;16506:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16506:25:0;;16484:47;;-1:-1:-1;;;16542:6:0;16549:1;16542:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;16542:15:0;;;;;;;;;-1:-1:-1;;;16568:6:0;16575:1;16568:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;16568:15:0;;;;;;;;-1:-1:-1;16599:9:0;16611:10;16615:6;16611:1;:10;:::i;:::-;:14;;16624:1;16611:14;:::i;:::-;16599:26;;16594:131;16631:1;16627;:5;16594:131;;;-1:-1:-1;;;16675:5:0;16683:3;16675:11;16666:21;;;;;;;:::i;:::-;;;;16654:6;16661:1;16654:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;16654:33:0;;;;;;;;-1:-1:-1;16712:1:0;16702:11;;;;;16634:3;;;:::i;:::-;;;16594:131;;;-1:-1:-1;16743:10:0;;16735:55;;;;-1:-1:-1;;;16735:55:0;;17726:2:1;16735:55:0;;;17708:21:1;;;17745:18;;;17738:30;17804:34;17784:18;;;17777:62;17856:18;;16735:55:0;17524:356:1;16735:55:0;16815:6;16383:447;-1:-1:-1;;;16383:447:0:o;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:160;215:20;;271:13;;264:21;254:32;;244:60;;300:1;297;290:12;244:60;150:160;;;:::o;315:315::-;380:6;388;441:2;429:9;420:7;416:23;412:32;409:52;;;457:1;454;447:12;409:52;496:9;483:23;515:31;540:5;515:31;:::i;:::-;565:5;-1:-1:-1;589:35:1;620:2;605:18;;589:35;:::i;:::-;579:45;;315:315;;;;;:::o;635:286::-;693:6;746:2;734:9;725:7;721:23;717:32;714:52;;;762:1;759;752:12;714:52;788:23;;-1:-1:-1;;;;;;840:32:1;;830:43;;820:71;;887:1;884;877:12;1118:250;1203:1;1213:113;1227:6;1224:1;1221:13;1213:113;;;1303:11;;;1297:18;1284:11;;;1277:39;1249:2;1242:10;1213:113;;;-1:-1:-1;;1360:1:1;1342:16;;1335:27;1118:250::o;1373:396::-;1522:2;1511:9;1504:21;1485:4;1554:6;1548:13;1597:6;1592:2;1581:9;1577:18;1570:34;1613:79;1685:6;1680:2;1669:9;1665:18;1660:2;1652:6;1648:15;1613:79;:::i;:::-;1753:2;1732:15;-1:-1:-1;;1728:29:1;1713:45;;;;1760:2;1709:54;;1373:396;-1:-1:-1;;1373:396:1:o;1774:315::-;1842:6;1850;1903:2;1891:9;1882:7;1878:23;1874:32;1871:52;;;1919:1;1916;1909:12;1871:52;1958:9;1945:23;1977:31;2002:5;1977:31;:::i;:::-;2027:5;2079:2;2064:18;;;;2051:32;;-1:-1:-1;;;1774:315:1:o;2276:456::-;2353:6;2361;2369;2422:2;2410:9;2401:7;2397:23;2393:32;2390:52;;;2438:1;2435;2428:12;2390:52;2477:9;2464:23;2496:31;2521:5;2496:31;:::i;:::-;2546:5;-1:-1:-1;2603:2:1;2588:18;;2575:32;2616:33;2575:32;2616:33;:::i;:::-;2276:456;;2668:7;;-1:-1:-1;;;2722:2:1;2707:18;;;;2694:32;;2276:456::o;2737:180::-;2796:6;2849:2;2837:9;2828:7;2824:23;2820:32;2817:52;;;2865:1;2862;2855:12;2817:52;-1:-1:-1;2888:23:1;;2737:180;-1:-1:-1;2737:180:1:o;3104:315::-;3172:6;3180;3233:2;3221:9;3212:7;3208:23;3204:32;3201:52;;;3249:1;3246;3239:12;3201:52;3285:9;3272:23;3262:33;;3345:2;3334:9;3330:18;3317:32;3358:31;3383:5;3358:31;:::i;:::-;3408:5;3398:15;;;3104:315;;;;;:::o;3821:247::-;3880:6;3933:2;3921:9;3912:7;3908:23;3904:32;3901:52;;;3949:1;3946;3939:12;3901:52;3988:9;3975:23;4007:31;4032:5;4007:31;:::i;4073:148::-;4146:20;;4195:1;4185:12;;4175:40;;4211:1;4208;4201:12;4226:159;4293:20;;4353:6;4342:18;;4332:29;;4322:57;;4375:1;4372;4365:12;4390:420;4485:6;4493;4501;4509;4562:3;4550:9;4541:7;4537:23;4533:33;4530:53;;;4579:1;4576;4569:12;4530:53;4602:34;4626:9;4602:34;:::i;:::-;4592:44;;4655:37;4688:2;4677:9;4673:18;4655:37;:::i;:::-;4645:47;;4711:37;4744:2;4733:9;4729:18;4711:37;:::i;:::-;4701:47;;4767:37;4800:2;4789:9;4785:18;4767:37;:::i;:::-;4757:47;;4390:420;;;;;;;:::o;5000:203::-;5071:6;5124:2;5112:9;5103:7;5099:23;5095:32;5092:52;;;5140:1;5137;5130:12;5092:52;5163:34;5187:9;5163:34;:::i;5627:180::-;5683:6;5736:2;5724:9;5715:7;5711:23;5707:32;5704:52;;;5752:1;5749;5742:12;5704:52;5775:26;5791:9;5775:26;:::i;5812:388::-;5880:6;5888;5941:2;5929:9;5920:7;5916:23;5912:32;5909:52;;;5957:1;5954;5947:12;5909:52;5996:9;5983:23;6015:31;6040:5;6015:31;:::i;:::-;6065:5;-1:-1:-1;6122:2:1;6107:18;;6094:32;6135:33;6094:32;6135:33;:::i;6205:411::-;6407:2;6389:21;;;6446:2;6426:18;;;6419:30;6485:34;6480:2;6465:18;;6458:62;-1:-1:-1;;;6551:2:1;6536:18;;6529:45;6606:3;6591:19;;6205:411::o;6621:380::-;6700:1;6696:12;;;;6743;;;6764:61;;6818:4;6810:6;6806:17;6796:27;;6764:61;6871:2;6863:6;6860:14;6840:18;6837:38;6834:161;;6917:10;6912:3;6908:20;6905:1;6898:31;6952:4;6949:1;6942:15;6980:4;6977:1;6970:15;6834:161;;6621:380;;;:::o;7422:127::-;7483:10;7478:3;7474:20;7471:1;7464:31;7514:4;7511:1;7504:15;7538:4;7535:1;7528:15;7554:125;7619:9;;;7640:10;;;7637:36;;;7653:18;;:::i;8032:168::-;8099:6;8125:10;;;8137;;;8121:27;;8160:11;;;8157:37;;;8174:18;;:::i;:::-;8157:37;8032:168;;;;:::o;8541:127::-;8602:10;8597:3;8593:20;8590:1;8583:31;8633:4;8630:1;8623:15;8657:4;8654:1;8647:15;13316:127;13377:10;13372:3;13368:20;13365:1;13358:31;13408:4;13405:1;13398:15;13432:4;13429:1;13422:15;13448:127;13509:10;13504:3;13500:20;13497:1;13490:31;13540:4;13537:1;13530:15;13564:4;13561:1;13554:15;13580:251;13650:6;13703:2;13691:9;13682:7;13678:23;13674:32;13671:52;;;13719:1;13716;13709:12;13671:52;13751:9;13745:16;13770:31;13795:5;13770:31;:::i;13836:980::-;14098:4;14146:3;14135:9;14131:19;14177:6;14166:9;14159:25;14203:2;14241:6;14236:2;14225:9;14221:18;14214:34;14284:3;14279:2;14268:9;14264:18;14257:31;14308:6;14343;14337:13;14374:6;14366;14359:22;14412:3;14401:9;14397:19;14390:26;;14451:2;14443:6;14439:15;14425:29;;14472:1;14482:195;14496:6;14493:1;14490:13;14482:195;;;14561:13;;-1:-1:-1;;;;;14557:39:1;14545:52;;14652:15;;;;14617:12;;;;14593:1;14511:9;14482:195;;;-1:-1:-1;;;;;;;14733:32:1;;;;14728:2;14713:18;;14706:60;-1:-1:-1;;;14797:3:1;14782:19;14775:35;14694:3;13836:980;-1:-1:-1;;;13836:980:1:o;14821:168::-;14894:9;;;14925;;14942:15;;;14936:22;;14922:37;14912:71;;14963:18;;:::i;14994:217::-;15034:1;15060;15050:132;;15104:10;15099:3;15095:20;15092:1;15085:31;15139:4;15136:1;15129:15;15167:4;15164:1;15157:15;15050:132;-1:-1:-1;15196:9:1;;14994:217::o;15216:128::-;15283:9;;;15304:11;;;15301:37;;;15318:18;;:::i;15349:812::-;15760:25;15755:3;15748:38;15730:3;15815:6;15809:13;15831:75;15899:6;15894:2;15889:3;15885:12;15878:4;15870:6;15866:17;15831:75;:::i;:::-;-1:-1:-1;;;15965:2:1;15925:16;;;15957:11;;;15950:40;16015:13;;16037:76;16015:13;16099:2;16091:11;;16084:4;16072:17;;16037:76;:::i;:::-;16133:17;16152:2;16129:26;;15349:812;-1:-1:-1;;;;15349:812:1:o;17383:136::-;17422:3;17450:5;17440:39;;17459:18;;:::i;:::-;-1:-1:-1;;;17495:18:1;;17383:136::o

ipfs://c96e83e09f8f6d2748442f6b64130fecc311d298a5cd1f55befd2ea811d1b4a3