Token CP PREMIUM SUBSCRIPTION

/**
 *Submitted for verification at Etherscan.io on 2023-02-07
*/

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


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// 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/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/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/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// 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/token/ERC721/IERC721.sol


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

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

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


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

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not token owner or approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
        _safeTransfer(from, to, tokenId, data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _ownerOf(tokenId) != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId, 1);

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256, /* firstTokenId */
        uint256 batchSize
    ) internal virtual {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}
}

// File: contracts/SubNFT.sol


pragma solidity ^0.8.17;






contract SubNFT is ERC721, Ownable {
    uint256 private constant TOTAL_SUPPLY = 1000;
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    uint256 nftPrice;
    address _paymentTokenAddr;

    // TokenURI for metadata:
    string private baseTokenURI;

    constructor(address tokenAddress) ERC721("CP PREMIUM SUBSCRIPTION", "CP") {
        _paymentTokenAddr = tokenAddress;
        baseTokenURI = "";
        nftPrice = 20000000000000000000000;
    }
    // Changes the NFT price in case we have to change it in the future. 
    function setNFTPrice(uint256 _nftPrice) public onlyOwner{
        nftPrice = _nftPrice;
    }
    /*
        Increase allowance in ERC20 token you are using for the payment, before attempting to mint with erc20 token. 
    */

    function erc20Mint(uint256 amount) public returns(uint256){
        require(amount == nftPrice,"Wrong Price!");
        uint256 tokenId = _tokenIds.current();
        require(tokenId < totalSupply(), "TOTAL SUPPLY HAS REACHED!");
        IERC20 token = IERC20(_paymentTokenAddr);
        token.transferFrom(msg.sender, address(token), amount);
        _tokenIds.increment();
        uint256 newNftId = _tokenIds.current();
        _mint(msg.sender, newNftId);
        return newNftId;
    }

    function mintFor(address receiver) public onlyOwner returns(uint256){
        uint256 tokenId = _tokenIds.current();
        require(tokenId < totalSupply(), "TOTAL SUPPLY HAS REACHED!");
        _tokenIds.increment();
        uint256 newNftId = _tokenIds.current();
        _mint(receiver, newNftId);
        return newNftId;
    }

    function totalSupply() public pure returns(uint256){
        return TOTAL_SUPPLY;
    }

    // BaseURI:
    function _baseURI() internal view virtual override returns (string memory){
        return baseTokenURI;
    }
    // Point to image on IPFS:
    function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner{
        baseTokenURI = _baseTokenURI;
    }
    // Override TOKENURI: 
    function tokenURI(uint256 tokenId) public view override returns (string memory){
         _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        // Not concatenating token ID anymore:
        return bytes(baseURI).length > 0 ? baseURI : "";
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"erc20Mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"mintFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseTokenURI","type":"string"}],"name":"setBaseTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nftPrice","type":"uint256"}],"name":"setNFTPrice","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":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000070eb1a48725622de867a7e3d1dd4f0108966ed1

-----Decoded View---------------
Arg [0] : tokenAddress (address): 0x070eb1a48725622de867a7e3d1dd4f0108966ed1

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000070eb1a48725622de867a7e3d1dd4f0108966ed1

58801:2365:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42888:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43816:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45328:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44846:416;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60473:89;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46028:335;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60737:117;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46434:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43526:223;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43257:207;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22319:103;;;:::i;:::-;;60126:339;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59380:95;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;21671:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43985:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45571:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46690:322;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59618:500;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60888:275;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45797:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22577:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42888:305;42990:4;43042:25;43027:40;;;:11;:40;;;;:105;;;;43099:33;43084:48;;;:11;:48;;;;43027:105;:158;;;;43149:36;43173:11;43149:23;:36::i;:::-;43027:158;43007:178;;42888:305;;;:::o;43816:100::-;43870:13;43903:5;43896:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43816:100;:::o;45328:171::-;45404:7;45424:23;45439:7;45424:14;:23::i;:::-;45467:15;:24;45483:7;45467:24;;;;;;;;;;;;;;;;;;;;;45460:31;;45328:171;;;:::o;44846:416::-;44927:13;44943:23;44958:7;44943:14;:23::i;:::-;44927:39;;44991:5;44985:11;;:2;:11;;;44977:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;45085:5;45069:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;45094:37;45111:5;45118:12;:10;:12::i;:::-;45094:16;:37::i;:::-;45069:62;45047:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;45233:21;45242:2;45246:7;45233:8;:21::i;:::-;44916:346;44846:416;;:::o;60473:89::-;60516:7;58883:4;60535:19;;60473:89;:::o;46028:335::-;46223:41;46242:12;:10;:12::i;:::-;46256:7;46223:18;:41::i;:::-;46215:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;46327:28;46337:4;46343:2;46347:7;46327:9;:28::i;:::-;46028:335;;;:::o;60737:117::-;21557:13;:11;:13::i;:::-;60833::::1;60818:12;:28;;;;;;:::i;:::-;;60737:117:::0;:::o;46434:185::-;46572:39;46589:4;46595:2;46599:7;46572:39;;;;;;;;;;;;:16;:39::i;:::-;46434:185;;;:::o;43526:223::-;43598:7;43618:13;43634:17;43643:7;43634:8;:17::i;:::-;43618:33;;43687:1;43670:19;;:5;:19;;;43662:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;43736:5;43729:12;;;43526:223;;;:::o;43257:207::-;43329:7;43374:1;43357:19;;:5;:19;;;43349:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;43440:9;:16;43450:5;43440:16;;;;;;;;;;;;;;;;43433:23;;43257:207;;;:::o;22319:103::-;21557:13;:11;:13::i;:::-;22384:30:::1;22411:1;22384:18;:30::i;:::-;22319:103::o:0;60126:339::-;60186:7;21557:13;:11;:13::i;:::-;60205:15:::1;60223:19;:9;:17;:19::i;:::-;60205:37;;60271:13;:11;:13::i;:::-;60261:7;:23;60253:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;60325:21;:9;:19;:21::i;:::-;60357:16;60376:19;:9;:17;:19::i;:::-;60357:38;;60406:25;60412:8;60422;60406:5;:25::i;:::-;60449:8;60442:15;;;;60126:339:::0;;;:::o;59380:95::-;21557:13;:11;:13::i;:::-;59458:9:::1;59447:8;:20;;;;59380:95:::0;:::o;21671:87::-;21717:7;21744:6;;;;;;;;;;;21737:13;;21671:87;:::o;43985:104::-;44041:13;44074:7;44067:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43985:104;:::o;45571:155::-;45666:52;45685:12;:10;:12::i;:::-;45699:8;45709;45666:18;:52::i;:::-;45571:155;;:::o;46690:322::-;46864:41;46883:12;:10;:12::i;:::-;46897:7;46864:18;:41::i;:::-;46856:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;46966:38;46980:4;46986:2;46990:7;46999:4;46966:13;:38::i;:::-;46690:322;;;;:::o;59618:500::-;59668:7;59705:8;;59695:6;:18;59687:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;59740:15;59758:19;:9;:17;:19::i;:::-;59740:37;;59806:13;:11;:13::i;:::-;59796:7;:23;59788:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;59860:12;59882:17;;;;;;;;;;;59860:40;;59911:5;:18;;;59930:10;59950:5;59958:6;59911:54;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;59976:21;:9;:19;:21::i;:::-;60008:16;60027:19;:9;:17;:19::i;:::-;60008:38;;60057:27;60063:10;60075:8;60057:5;:27::i;:::-;60102:8;60095:15;;;;;59618:500;;;:::o;60888:275::-;60953:13;60979:23;60994:7;60979:14;:23::i;:::-;61015:21;61039:10;:8;:10::i;:::-;61015:34;;61139:1;61121:7;61115:21;:25;:40;;;;;;;;;;;;;;;;;61143:7;61115:40;61108:47;;;60888:275;;;:::o;45797:164::-;45894:4;45918:18;:25;45937:5;45918:25;;;;;;;;;;;;;;;:35;45944:8;45918:35;;;;;;;;;;;;;;;;;;;;;;;;;45911:42;;45797:164;;;;:::o;22577:201::-;21557:13;:11;:13::i;:::-;22686:1:::1;22666:22;;:8;:22;;::::0;22658:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;22742:28;22761:8;22742:18;:28::i;:::-;22577:201:::0;:::o;35400:157::-;35485:4;35524:25;35509:40;;;:11;:40;;;;35502:47;;35400:157;;;:::o;55147:135::-;55229:16;55237:7;55229;:16::i;:::-;55221:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;55147:135;:::o;20222:98::-;20275:7;20302:10;20295:17;;20222:98;:::o;54426:174::-;54528:2;54501:15;:24;54517:7;54501:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;54584:7;54580:2;54546:46;;54555:23;54570:7;54555:14;:23::i;:::-;54546:46;;;;;;;;;;;;54426:174;;:::o;49045:264::-;49138:4;49155:13;49171:23;49186:7;49171:14;:23::i;:::-;49155:39;;49224:5;49213:16;;:7;:16;;;:52;;;;49233:32;49250:5;49257:7;49233:16;:32::i;:::-;49213:52;:87;;;;49293:7;49269:31;;:20;49281:7;49269:11;:20::i;:::-;:31;;;49213:87;49205:96;;;49045:264;;;;:::o;53044:1263::-;53203:4;53176:31;;:23;53191:7;53176:14;:23::i;:::-;:31;;;53168:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;53282:1;53268:16;;:2;:16;;;53260:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;53338:42;53359:4;53365:2;53369:7;53378:1;53338:20;:42::i;:::-;53510:4;53483:31;;:23;53498:7;53483:14;:23::i;:::-;:31;;;53475:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;53628:15;:24;53644:7;53628:24;;;;;;;;;;;;53621:31;;;;;;;;;;;54123:1;54104:9;:15;54114:4;54104:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;54156:1;54139:9;:13;54149:2;54139:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;54198:2;54179:7;:16;54187:7;54179:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;54237:7;54233:2;54218:27;;54227:4;54218:27;;;;;;;;;;;;54258:41;54278:4;54284:2;54288:7;54297:1;54258:19;:41::i;:::-;53044:1263;;;:::o;21836:132::-;21911:12;:10;:12::i;:::-;21900:23;;:7;:5;:7::i;:::-;:23;;;21892:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;21836:132::o;48320:117::-;48386:7;48413;:16;48421:7;48413:16;;;;;;;;;;;;;;;;;;;;;48406:23;;48320:117;;;:::o;22938:191::-;23012:16;23031:6;;;;;;;;;;;23012:25;;23057:8;23048:6;;:17;;;;;;;;;;;;;;;;;;23112:8;23081:40;;23102:8;23081:40;;;;;;;;;;;;23001:128;22938:191;:::o;872:114::-;937:7;964;:14;;;957:21;;872:114;;;:::o;994:127::-;1101:1;1083:7;:14;;;:19;;;;;;;;;;;994:127;:::o;50643:942::-;50737:1;50723:16;;:2;:16;;;50715:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;50796:16;50804:7;50796;:16::i;:::-;50795:17;50787:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;50858:48;50887:1;50891:2;50895:7;50904:1;50858:20;:48::i;:::-;51005:16;51013:7;51005;:16::i;:::-;51004:17;50996:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;51420:1;51403:9;:13;51413:2;51403:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;51464:2;51445:7;:16;51453:7;51445:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;51509:7;51505:2;51484:33;;51501:1;51484:33;;;;;;;;;;;;51530:47;51558:1;51562:2;51566:7;51575:1;51530:19;:47::i;:::-;50643:942;;:::o;54743:315::-;54898:8;54889:17;;:5;:17;;;54881:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;54985:8;54947:18;:25;54966:5;54947:25;;;;;;;;;;;;;;;:35;54973:8;54947:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;55031:8;55009:41;;55024:5;55009:41;;;55041:8;55009:41;;;;;;:::i;:::-;;;;;;;;54743:315;;;:::o;47893:313::-;48049:28;48059:4;48065:2;48069:7;48049:9;:28::i;:::-;48096:47;48119:4;48125:2;48129:7;48138:4;48096:22;:47::i;:::-;48088:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;47893:313;;;;:::o;60587:112::-;60647:13;60679:12;60672:19;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60587:112;:::o;48750:128::-;48815:4;48868:1;48839:31;;:17;48848:7;48839:8;:17::i;:::-;:31;;;;48832:38;;48750:128;;;:::o;57431:410::-;57621:1;57609:9;:13;57605:229;;;57659:1;57643:18;;:4;:18;;;57639:87;;57701:9;57682;:15;57692:4;57682:15;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;57639:87;57758:1;57744:16;;:2;:16;;;57740:83;;57798:9;57781;:13;57791:2;57781:13;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;57740:83;57605:229;57431:410;;;;:::o;58563:158::-;;;;;:::o;55846:853::-;56000:4;56021:15;:2;:13;;;:15::i;:::-;56017:675;;;56073:2;56057:36;;;56094:12;:10;:12::i;:::-;56108:4;56114:7;56123:4;56057:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;56053:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56315:1;56298:6;:13;:18;56294:328;;56341:60;;;;;;;;;;:::i;:::-;;;;;;;;56294:328;56572:6;56566:13;56557:6;56553:2;56549:15;56542:38;56053:584;56189:41;;;56179:51;;;:6;:51;;;;56172:58;;;;;56017:675;56676:4;56669:11;;55846:853;;;;;;;:::o;24369:326::-;24429:4;24686:1;24664:7;:19;;;:23;24657:30;;24369:326;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:118::-;4977:24;4995:5;4977:24;:::i;:::-;4972:3;4965:37;4890:118;;:::o;5014:222::-;5107:4;5145:2;5134:9;5130:18;5122:26;;5158:71;5226:1;5215:9;5211:17;5202:6;5158:71;:::i;:::-;5014:222;;;;:::o;5242:619::-;5319:6;5327;5335;5384:2;5372:9;5363:7;5359:23;5355:32;5352:119;;;5390:79;;:::i;:::-;5352:119;5510:1;5535:53;5580:7;5571:6;5560:9;5556:22;5535:53;:::i;:::-;5525:63;;5481:117;5637:2;5663:53;5708:7;5699:6;5688:9;5684:22;5663:53;:::i;:::-;5653:63;;5608:118;5765:2;5791:53;5836:7;5827:6;5816:9;5812:22;5791:53;:::i;:::-;5781:63;;5736:118;5242:619;;;;;:::o;5867:117::-;5976:1;5973;5966:12;5990:117;6099:1;6096;6089:12;6113:180;6161:77;6158:1;6151:88;6258:4;6255:1;6248:15;6282:4;6279:1;6272:15;6299:281;6382:27;6404:4;6382:27;:::i;:::-;6374:6;6370:40;6512:6;6500:10;6497:22;6476:18;6464:10;6461:34;6458:62;6455:88;;;6523:18;;:::i;:::-;6455:88;6563:10;6559:2;6552:22;6342:238;6299:281;;:::o;6586:129::-;6620:6;6647:20;;:::i;:::-;6637:30;;6676:33;6704:4;6696:6;6676:33;:::i;:::-;6586:129;;;:::o;6721:308::-;6783:4;6873:18;6865:6;6862:30;6859:56;;;6895:18;;:::i;:::-;6859:56;6933:29;6955:6;6933:29;:::i;:::-;6925:37;;7017:4;7011;7007:15;6999:23;;6721:308;;;:::o;7035:146::-;7132:6;7127:3;7122;7109:30;7173:1;7164:6;7159:3;7155:16;7148:27;7035:146;;;:::o;7187:425::-;7265:5;7290:66;7306:49;7348:6;7306:49;:::i;:::-;7290:66;:::i;:::-;7281:75;;7379:6;7372:5;7365:21;7417:4;7410:5;7406:16;7455:3;7446:6;7441:3;7437:16;7434:25;7431:112;;;7462:79;;:::i;:::-;7431:112;7552:54;7599:6;7594:3;7589;7552:54;:::i;:::-;7271:341;7187:425;;;;;:::o;7632:340::-;7688:5;7737:3;7730:4;7722:6;7718:17;7714:27;7704:122;;7745:79;;:::i;:::-;7704:122;7862:6;7849:20;7887:79;7962:3;7954:6;7947:4;7939:6;7935:17;7887:79;:::i;:::-;7878:88;;7694:278;7632:340;;;;:::o;7978:509::-;8047:6;8096:2;8084:9;8075:7;8071:23;8067:32;8064:119;;;8102:79;;:::i;:::-;8064:119;8250:1;8239:9;8235:17;8222:31;8280:18;8272:6;8269:30;8266:117;;;8302:79;;:::i;:::-;8266:117;8407:63;8462:7;8453:6;8442:9;8438:22;8407:63;:::i;:::-;8397:73;;8193:287;7978:509;;;;:::o;8493:329::-;8552:6;8601:2;8589:9;8580:7;8576:23;8572:32;8569:119;;;8607:79;;:::i;:::-;8569:119;8727:1;8752:53;8797:7;8788:6;8777:9;8773:22;8752:53;:::i;:::-;8742:63;;8698:117;8493:329;;;;:::o;8828:116::-;8898:21;8913:5;8898:21;:::i;:::-;8891:5;8888:32;8878:60;;8934:1;8931;8924:12;8878:60;8828:116;:::o;8950:133::-;8993:5;9031:6;9018:20;9009:29;;9047:30;9071:5;9047:30;:::i;:::-;8950:133;;;;:::o;9089:468::-;9154:6;9162;9211:2;9199:9;9190:7;9186:23;9182:32;9179:119;;;9217:79;;:::i;:::-;9179:119;9337:1;9362:53;9407:7;9398:6;9387:9;9383:22;9362:53;:::i;:::-;9352:63;;9308:117;9464:2;9490:50;9532:7;9523:6;9512:9;9508:22;9490:50;:::i;:::-;9480:60;;9435:115;9089:468;;;;;:::o;9563:307::-;9624:4;9714:18;9706:6;9703:30;9700:56;;;9736:18;;:::i;:::-;9700:56;9774:29;9796:6;9774:29;:::i;:::-;9766:37;;9858:4;9852;9848:15;9840:23;;9563:307;;;:::o;9876:423::-;9953:5;9978:65;9994:48;10035:6;9994:48;:::i;:::-;9978:65;:::i;:::-;9969:74;;10066:6;10059:5;10052:21;10104:4;10097:5;10093:16;10142:3;10133:6;10128:3;10124:16;10121:25;10118:112;;;10149:79;;:::i;:::-;10118:112;10239:54;10286:6;10281:3;10276;10239:54;:::i;:::-;9959:340;9876:423;;;;;:::o;10318:338::-;10373:5;10422:3;10415:4;10407:6;10403:17;10399:27;10389:122;;10430:79;;:::i;:::-;10389:122;10547:6;10534:20;10572:78;10646:3;10638:6;10631:4;10623:6;10619:17;10572:78;:::i;:::-;10563:87;;10379:277;10318:338;;;;:::o;10662:943::-;10757:6;10765;10773;10781;10830:3;10818:9;10809:7;10805:23;10801:33;10798:120;;;10837:79;;:::i;:::-;10798:120;10957:1;10982:53;11027:7;11018:6;11007:9;11003:22;10982:53;:::i;:::-;10972:63;;10928:117;11084:2;11110:53;11155:7;11146:6;11135:9;11131:22;11110:53;:::i;:::-;11100:63;;11055:118;11212:2;11238:53;11283:7;11274:6;11263:9;11259:22;11238:53;:::i;:::-;11228:63;;11183:118;11368:2;11357:9;11353:18;11340:32;11399:18;11391:6;11388:30;11385:117;;;11421:79;;:::i;:::-;11385:117;11526:62;11580:7;11571:6;11560:9;11556:22;11526:62;:::i;:::-;11516:72;;11311:287;10662:943;;;;;;;:::o;11611:474::-;11679:6;11687;11736:2;11724:9;11715:7;11711:23;11707:32;11704:119;;;11742:79;;:::i;:::-;11704:119;11862:1;11887:53;11932:7;11923:6;11912:9;11908:22;11887:53;:::i;:::-;11877:63;;11833:117;11989:2;12015:53;12060:7;12051:6;12040:9;12036:22;12015:53;:::i;:::-;12005:63;;11960:118;11611:474;;;;;:::o;12091:180::-;12139:77;12136:1;12129:88;12236:4;12233:1;12226:15;12260:4;12257:1;12250:15;12277:320;12321:6;12358:1;12352:4;12348:12;12338:22;;12405:1;12399:4;12395:12;12426:18;12416:81;;12482:4;12474:6;12470:17;12460:27;;12416:81;12544:2;12536:6;12533:14;12513:18;12510:38;12507:84;;12563:18;;:::i;:::-;12507:84;12328:269;12277:320;;;:::o;12603:220::-;12743:34;12739:1;12731:6;12727:14;12720:58;12812:3;12807:2;12799:6;12795:15;12788:28;12603:220;:::o;12829:366::-;12971:3;12992:67;13056:2;13051:3;12992:67;:::i;:::-;12985:74;;13068:93;13157:3;13068:93;:::i;:::-;13186:2;13181:3;13177:12;13170:19;;12829:366;;;:::o;13201:419::-;13367:4;13405:2;13394:9;13390:18;13382:26;;13454:9;13448:4;13444:20;13440:1;13429:9;13425:17;13418:47;13482:131;13608:4;13482:131;:::i;:::-;13474:139;;13201:419;;;:::o;13626:248::-;13766:34;13762:1;13754:6;13750:14;13743:58;13835:31;13830:2;13822:6;13818:15;13811:56;13626:248;:::o;13880:366::-;14022:3;14043:67;14107:2;14102:3;14043:67;:::i;:::-;14036:74;;14119:93;14208:3;14119:93;:::i;:::-;14237:2;14232:3;14228:12;14221:19;;13880:366;;;:::o;14252:419::-;14418:4;14456:2;14445:9;14441:18;14433:26;;14505:9;14499:4;14495:20;14491:1;14480:9;14476:17;14469:47;14533:131;14659:4;14533:131;:::i;:::-;14525:139;;14252:419;;;:::o;14677:232::-;14817:34;14813:1;14805:6;14801:14;14794:58;14886:15;14881:2;14873:6;14869:15;14862:40;14677:232;:::o;14915:366::-;15057:3;15078:67;15142:2;15137:3;15078:67;:::i;:::-;15071:74;;15154:93;15243:3;15154:93;:::i;:::-;15272:2;15267:3;15263:12;15256:19;;14915:366;;;:::o;15287:419::-;15453:4;15491:2;15480:9;15476:18;15468:26;;15540:9;15534:4;15530:20;15526:1;15515:9;15511:17;15504:47;15568:131;15694:4;15568:131;:::i;:::-;15560:139;;15287:419;;;:::o;15712:141::-;15761:4;15784:3;15776:11;;15807:3;15804:1;15797:14;15841:4;15838:1;15828:18;15820:26;;15712:141;;;:::o;15859:93::-;15896:6;15943:2;15938;15931:5;15927:14;15923:23;15913:33;;15859:93;;;:::o;15958:107::-;16002:8;16052:5;16046:4;16042:16;16021:37;;15958:107;;;;:::o;16071:393::-;16140:6;16190:1;16178:10;16174:18;16213:97;16243:66;16232:9;16213:97;:::i;:::-;16331:39;16361:8;16350:9;16331:39;:::i;:::-;16319:51;;16403:4;16399:9;16392:5;16388:21;16379:30;;16452:4;16442:8;16438:19;16431:5;16428:30;16418:40;;16147:317;;16071:393;;;;;:::o;16470:60::-;16498:3;16519:5;16512:12;;16470:60;;;:::o;16536:142::-;16586:9;16619:53;16637:34;16646:24;16664:5;16646:24;:::i;:::-;16637:34;:::i;:::-;16619:53;:::i;:::-;16606:66;;16536:142;;;:::o;16684:75::-;16727:3;16748:5;16741:12;;16684:75;;;:::o;16765:269::-;16875:39;16906:7;16875:39;:::i;:::-;16936:91;16985:41;17009:16;16985:41;:::i;:::-;16977:6;16970:4;16964:11;16936:91;:::i;:::-;16930:4;16923:105;16841:193;16765:269;;;:::o;17040:73::-;17085:3;17040:73;:::o;17119:189::-;17196:32;;:::i;:::-;17237:65;17295:6;17287;17281:4;17237:65;:::i;:::-;17172:136;17119:189;;:::o;17314:186::-;17374:120;17391:3;17384:5;17381:14;17374:120;;;17445:39;17482:1;17475:5;17445:39;:::i;:::-;17418:1;17411:5;17407:13;17398:22;;17374:120;;;17314:186;;:::o;17506:543::-;17607:2;17602:3;17599:11;17596:446;;;17641:38;17673:5;17641:38;:::i;:::-;17725:29;17743:10;17725:29;:::i;:::-;17715:8;17711:44;17908:2;17896:10;17893:18;17890:49;;;17929:8;17914:23;;17890:49;17952:80;18008:22;18026:3;18008:22;:::i;:::-;17998:8;17994:37;17981:11;17952:80;:::i;:::-;17611:431;;17596:446;17506:543;;;:::o;18055:117::-;18109:8;18159:5;18153:4;18149:16;18128:37;;18055:117;;;;:::o;18178:169::-;18222:6;18255:51;18303:1;18299:6;18291:5;18288:1;18284:13;18255:51;:::i;:::-;18251:56;18336:4;18330;18326:15;18316:25;;18229:118;18178:169;;;;:::o;18352:295::-;18428:4;18574:29;18599:3;18593:4;18574:29;:::i;:::-;18566:37;;18636:3;18633:1;18629:11;18623:4;18620:21;18612:29;;18352:295;;;;:::o;18652:1395::-;18769:37;18802:3;18769:37;:::i;:::-;18871:18;18863:6;18860:30;18857:56;;;18893:18;;:::i;:::-;18857:56;18937:38;18969:4;18963:11;18937:38;:::i;:::-;19022:67;19082:6;19074;19068:4;19022:67;:::i;:::-;19116:1;19140:4;19127:17;;19172:2;19164:6;19161:14;19189:1;19184:618;;;;19846:1;19863:6;19860:77;;;19912:9;19907:3;19903:19;19897:26;19888:35;;19860:77;19963:67;20023:6;20016:5;19963:67;:::i;:::-;19957:4;19950:81;19819:222;19154:887;;19184:618;19236:4;19232:9;19224:6;19220:22;19270:37;19302:4;19270:37;:::i;:::-;19329:1;19343:208;19357:7;19354:1;19351:14;19343:208;;;19436:9;19431:3;19427:19;19421:26;19413:6;19406:42;19487:1;19479:6;19475:14;19465:24;;19534:2;19523:9;19519:18;19506:31;;19380:4;19377:1;19373:12;19368:17;;19343:208;;;19579:6;19570:7;19567:19;19564:179;;;19637:9;19632:3;19628:19;19622:26;19680:48;19722:4;19714:6;19710:17;19699:9;19680:48;:::i;:::-;19672:6;19665:64;19587:156;19564:179;19789:1;19785;19777:6;19773:14;19769:22;19763:4;19756:36;19191:611;;;19154:887;;18744:1303;;;18652:1395;;:::o;20053:174::-;20193:26;20189:1;20181:6;20177:14;20170:50;20053:174;:::o;20233:366::-;20375:3;20396:67;20460:2;20455:3;20396:67;:::i;:::-;20389:74;;20472:93;20561:3;20472:93;:::i;:::-;20590:2;20585:3;20581:12;20574:19;;20233:366;;;:::o;20605:419::-;20771:4;20809:2;20798:9;20794:18;20786:26;;20858:9;20852:4;20848:20;20844:1;20833:9;20829:17;20822:47;20886:131;21012:4;20886:131;:::i;:::-;20878:139;;20605:419;;;:::o;21030:228::-;21170:34;21166:1;21158:6;21154:14;21147:58;21239:11;21234:2;21226:6;21222:15;21215:36;21030:228;:::o;21264:366::-;21406:3;21427:67;21491:2;21486:3;21427:67;:::i;:::-;21420:74;;21503:93;21592:3;21503:93;:::i;:::-;21621:2;21616:3;21612:12;21605:19;;21264:366;;;:::o;21636:419::-;21802:4;21840:2;21829:9;21825:18;21817:26;;21889:9;21883:4;21879:20;21875:1;21864:9;21860:17;21853:47;21917:131;22043:4;21917:131;:::i;:::-;21909:139;;21636:419;;;:::o;22061:175::-;22201:27;22197:1;22189:6;22185:14;22178:51;22061:175;:::o;22242:366::-;22384:3;22405:67;22469:2;22464:3;22405:67;:::i;:::-;22398:74;;22481:93;22570:3;22481:93;:::i;:::-;22599:2;22594:3;22590:12;22583:19;;22242:366;;;:::o;22614:419::-;22780:4;22818:2;22807:9;22803:18;22795:26;;22867:9;22861:4;22857:20;22853:1;22842:9;22838:17;22831:47;22895:131;23021:4;22895:131;:::i;:::-;22887:139;;22614:419;;;:::o;23039:162::-;23179:14;23175:1;23167:6;23163:14;23156:38;23039:162;:::o;23207:366::-;23349:3;23370:67;23434:2;23429:3;23370:67;:::i;:::-;23363:74;;23446:93;23535:3;23446:93;:::i;:::-;23564:2;23559:3;23555:12;23548:19;;23207:366;;;:::o;23579:419::-;23745:4;23783:2;23772:9;23768:18;23760:26;;23832:9;23826:4;23822:20;23818:1;23807:9;23803:17;23796:47;23860:131;23986:4;23860:131;:::i;:::-;23852:139;;23579:419;;;:::o;24004:442::-;24153:4;24191:2;24180:9;24176:18;24168:26;;24204:71;24272:1;24261:9;24257:17;24248:6;24204:71;:::i;:::-;24285:72;24353:2;24342:9;24338:18;24329:6;24285:72;:::i;:::-;24367;24435:2;24424:9;24420:18;24411:6;24367:72;:::i;:::-;24004:442;;;;;;:::o;24452:137::-;24506:5;24537:6;24531:13;24522:22;;24553:30;24577:5;24553:30;:::i;:::-;24452:137;;;;:::o;24595:345::-;24662:6;24711:2;24699:9;24690:7;24686:23;24682:32;24679:119;;;24717:79;;:::i;:::-;24679:119;24837:1;24862:61;24915:7;24906:6;24895:9;24891:22;24862:61;:::i;:::-;24852:71;;24808:125;24595:345;;;;:::o;24946:225::-;25086:34;25082:1;25074:6;25070:14;25063:58;25155:8;25150:2;25142:6;25138:15;25131:33;24946:225;:::o;25177:366::-;25319:3;25340:67;25404:2;25399:3;25340:67;:::i;:::-;25333:74;;25416:93;25505:3;25416:93;:::i;:::-;25534:2;25529:3;25525:12;25518:19;;25177:366;;;:::o;25549:419::-;25715:4;25753:2;25742:9;25738:18;25730:26;;25802:9;25796:4;25792:20;25788:1;25777:9;25773:17;25766:47;25830:131;25956:4;25830:131;:::i;:::-;25822:139;;25549:419;;;:::o;25974:224::-;26114:34;26110:1;26102:6;26098:14;26091:58;26183:7;26178:2;26170:6;26166:15;26159:32;25974:224;:::o;26204:366::-;26346:3;26367:67;26431:2;26426:3;26367:67;:::i;:::-;26360:74;;26443:93;26532:3;26443:93;:::i;:::-;26561:2;26556:3;26552:12;26545:19;;26204:366;;;:::o;26576:419::-;26742:4;26780:2;26769:9;26765:18;26757:26;;26829:9;26823:4;26819:20;26815:1;26804:9;26800:17;26793:47;26857:131;26983:4;26857:131;:::i;:::-;26849:139;;26576:419;;;:::o;27001:223::-;27141:34;27137:1;27129:6;27125:14;27118:58;27210:6;27205:2;27197:6;27193:15;27186:31;27001:223;:::o;27230:366::-;27372:3;27393:67;27457:2;27452:3;27393:67;:::i;:::-;27386:74;;27469:93;27558:3;27469:93;:::i;:::-;27587:2;27582:3;27578:12;27571:19;;27230:366;;;:::o;27602:419::-;27768:4;27806:2;27795:9;27791:18;27783:26;;27855:9;27849:4;27845:20;27841:1;27830:9;27826:17;27819:47;27883:131;28009:4;27883:131;:::i;:::-;27875:139;;27602:419;;;:::o;28027:182::-;28167:34;28163:1;28155:6;28151:14;28144:58;28027:182;:::o;28215:366::-;28357:3;28378:67;28442:2;28437:3;28378:67;:::i;:::-;28371:74;;28454:93;28543:3;28454:93;:::i;:::-;28572:2;28567:3;28563:12;28556:19;;28215:366;;;:::o;28587:419::-;28753:4;28791:2;28780:9;28776:18;28768:26;;28840:9;28834:4;28830:20;28826:1;28815:9;28811:17;28804:47;28868:131;28994:4;28868:131;:::i;:::-;28860:139;;28587:419;;;:::o;29012:182::-;29152:34;29148:1;29140:6;29136:14;29129:58;29012:182;:::o;29200:366::-;29342:3;29363:67;29427:2;29422:3;29363:67;:::i;:::-;29356:74;;29439:93;29528:3;29439:93;:::i;:::-;29557:2;29552:3;29548:12;29541:19;;29200:366;;;:::o;29572:419::-;29738:4;29776:2;29765:9;29761:18;29753:26;;29825:9;29819:4;29815:20;29811:1;29800:9;29796:17;29789:47;29853:131;29979:4;29853:131;:::i;:::-;29845:139;;29572:419;;;:::o;29997:178::-;30137:30;30133:1;30125:6;30121:14;30114:54;29997:178;:::o;30181:366::-;30323:3;30344:67;30408:2;30403:3;30344:67;:::i;:::-;30337:74;;30420:93;30509:3;30420:93;:::i;:::-;30538:2;30533:3;30529:12;30522:19;;30181:366;;;:::o;30553:419::-;30719:4;30757:2;30746:9;30742:18;30734:26;;30806:9;30800:4;30796:20;30792:1;30781:9;30777:17;30770:47;30834:131;30960:4;30834:131;:::i;:::-;30826:139;;30553:419;;;:::o;30978:175::-;31118:27;31114:1;31106:6;31102:14;31095:51;30978:175;:::o;31159:366::-;31301:3;31322:67;31386:2;31381:3;31322:67;:::i;:::-;31315:74;;31398:93;31487:3;31398:93;:::i;:::-;31516:2;31511:3;31507:12;31500:19;;31159:366;;;:::o;31531:419::-;31697:4;31735:2;31724:9;31720:18;31712:26;;31784:9;31778:4;31774:20;31770:1;31759:9;31755:17;31748:47;31812:131;31938:4;31812:131;:::i;:::-;31804:139;;31531:419;;;:::o;31956:237::-;32096:34;32092:1;32084:6;32080:14;32073:58;32165:20;32160:2;32152:6;32148:15;32141:45;31956:237;:::o;32199:366::-;32341:3;32362:67;32426:2;32421:3;32362:67;:::i;:::-;32355:74;;32438:93;32527:3;32438:93;:::i;:::-;32556:2;32551:3;32547:12;32540:19;;32199:366;;;:::o;32571:419::-;32737:4;32775:2;32764:9;32760:18;32752:26;;32824:9;32818:4;32814:20;32810:1;32799:9;32795:17;32788:47;32852:131;32978:4;32852:131;:::i;:::-;32844:139;;32571:419;;;:::o;32996:180::-;33044:77;33041:1;33034:88;33141:4;33138:1;33131:15;33165:4;33162:1;33155:15;33182:194;33222:4;33242:20;33260:1;33242:20;:::i;:::-;33237:25;;33276:20;33294:1;33276:20;:::i;:::-;33271:25;;33320:1;33317;33313:9;33305:17;;33344:1;33338:4;33335:11;33332:37;;;33349:18;;:::i;:::-;33332:37;33182:194;;;;:::o;33382:191::-;33422:3;33441:20;33459:1;33441:20;:::i;:::-;33436:25;;33475:20;33493:1;33475:20;:::i;:::-;33470:25;;33518:1;33515;33511:9;33504:16;;33539:3;33536:1;33533:10;33530:36;;;33546:18;;:::i;:::-;33530:36;33382:191;;;;:::o;33579:98::-;33630:6;33664:5;33658:12;33648:22;;33579:98;;;:::o;33683:168::-;33766:11;33800:6;33795:3;33788:19;33840:4;33835:3;33831:14;33816:29;;33683:168;;;;:::o;33857:373::-;33943:3;33971:38;34003:5;33971:38;:::i;:::-;34025:70;34088:6;34083:3;34025:70;:::i;:::-;34018:77;;34104:65;34162:6;34157:3;34150:4;34143:5;34139:16;34104:65;:::i;:::-;34194:29;34216:6;34194:29;:::i;:::-;34189:3;34185:39;34178:46;;33947:283;33857:373;;;;:::o;34236:640::-;34431:4;34469:3;34458:9;34454:19;34446:27;;34483:71;34551:1;34540:9;34536:17;34527:6;34483:71;:::i;:::-;34564:72;34632:2;34621:9;34617:18;34608:6;34564:72;:::i;:::-;34646;34714:2;34703:9;34699:18;34690:6;34646:72;:::i;:::-;34765:9;34759:4;34755:20;34750:2;34739:9;34735:18;34728:48;34793:76;34864:4;34855:6;34793:76;:::i;:::-;34785:84;;34236:640;;;;;;;:::o;34882:141::-;34938:5;34969:6;34963:13;34954:22;;34985:32;35011:5;34985:32;:::i;:::-;34882:141;;;;:::o;35029:349::-;35098:6;35147:2;35135:9;35126:7;35122:23;35118:32;35115:119;;;35153:79;;:::i;:::-;35115:119;35273:1;35298:63;35353:7;35344:6;35333:9;35329:22;35298:63;:::i;:::-;35288:73;;35244:127;35029:349;;;;:::o

ipfs://2ddfb4382ad807e59be08ef3fa0728738284977e458bea339e84f147bf41d5ec