Token CROnk O.G

/**
 *Submitted for verification at Etherscan.io on 2023-05-18
*/

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


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// 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/utils/Context.sol


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts (last updated v4.8.2) (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 {}

    /**
     * @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 {}

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
     * that `ownerOf(tokenId)` is `a`.
     */
    // solhint-disable-next-line func-name-mixedcase
    function __unsafe_increaseBalance(address account, uint256 amount) internal {
        _balances[account] += amount;
    }
}

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


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

pragma solidity ^0.8.0;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

        if (batchSize > 1) {
            // Will only trigger during construction. Batch transferring (minting) is not available afterwards.
            revert("ERC721Enumerable: consecutive transfers not supported");
        }

        uint256 tokenId = firstTokenId;

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// File: @openzeppelin/contracts/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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


pragma solidity ^0.8.0;






contract CROnkNFT is ERC721Enumerable, Pausable, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _mintCounter;

    uint256 public _maxMintable = 1000;
    uint256 public _mintPrice = 25 ether;
    uint256 public _maxPerTx = 5;

    // Base URI for metadata 
    string public _prefixURI;

    constructor() ERC721("CROnk O.G", "CRONK") {
        toggleAllMintPause();
    }

    function mint(uint256 amount) external payable whenNotPaused {
        require(amount <= _maxPerTx, "mint: Mint amount exceeds max mint per transaction");
        uint256 currentMintCount = _mintCounter.current();
        require(currentMintCount < _maxMintable, "mint: no NFTs left to mint");
        require(currentMintCount + amount <= _maxMintable, "mint: not enough NFTs available to mint that amount");
        require(msg.value == amount * _mintPrice, "mint: value is not correct to mint that amount");

        for (uint256 i = 0; i < amount; i++) {
            _mintItem(msg.sender);
        }
    }

    function _mintItem(address to) internal {
        _mintCounter.increment();
        uint256 id = _mintCounter.current();
        _safeMint(to, id);
    }

    function _baseURI() internal view override returns (string memory) {
        return _prefixURI;
    }

    function airDrop(address[] memory addrs) external  onlyOwner {
        uint256 currentMintCount = _mintCounter.current();
        require(addrs.length > 0, "airDrop: must specify at least one address");
        require(currentMintCount + addrs.length <= _maxMintable, "airDrop: maximum supply reached");
        for (uint256 i = 0; i < addrs.length; i++) {
            _mintItem(addrs[i]); 
        }
    }

    function setBaseURI(string memory _uri) public onlyOwner {
        _prefixURI = _uri;
    }

    function burnToken(uint256 tokenId) external virtual {
        require(_isApprovedOrOwner(msg.sender, tokenId), "burnToken: caller is not owner nor approved"); 
        _burn(tokenId);
    }

    function toggleAllMintPause() public onlyOwner {
        paused() ? _unpause() : _pause();
    }

    function updatePrice(uint256 newPrice) external onlyOwner {
        require(newPrice > 0, "updatePrice: new price must be greater than 0");
        _mintPrice = newPrice; 
    }

    function updateTotalSupply(uint256 newSupply) external onlyOwner {
        require(newSupply > 0, "updateTotalSupply: new supply must be greater than 0"); 
        _maxMintable = newSupply;
    }
    
    function updateMaxPerTx(uint256 _max) external onlyOwner {
        _maxPerTx = _max;
    }

    function withdraw() external onlyOwner {
        require(address(this).balance > 0, "withdraw: contract balance must be greater than 0"); 
        uint256 balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    function withdrawTokens(address token, uint256 amount) external onlyOwner {
        require(amount > 0, "withdrawTokens: Contract does not have tokens to withdraw");
        IERC20(token).transfer(msg.sender, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"_maxMintable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_maxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_prefixURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addrs","type":"address[]"}],"name":"airDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"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":"tokenId","type":"uint256"}],"name":"burnToken","outputs":[],"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":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","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":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"_uri","type":"string"}],"name":"setBaseURI","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":[],"name":"toggleAllMintPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"view","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"},{"inputs":[{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"updateMaxPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"updatePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newSupply","type":"uint256"}],"name":"updateTotalSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

69850:3137:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71179:413;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57024:224;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70043:36;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72758:226;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40731:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42243:171;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41761:416;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57664:113;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42943:335;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71902:98;;;;;;;;;;;;;:::i;:::-;;57332:256;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72506:244;;;;;;;;;;;;;:::i;:::-;;43349:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57854:233;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71600:93;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;64632:86;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40441:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72196:198;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40172:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67497:103;;;;;;;;;;;;;:::i;:::-;;71701:193;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72406:92;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72008:180;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66849:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70154:24;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40900:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70277:618;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42486:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70086:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43605:322;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;41075:281;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70002:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42712:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67755:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71179:413;66735:13;:11;:13::i;:::-;71251:24:::1;71278:22;:12;:20;:22::i;:::-;71251:49;;71334:1;71319:5;:12;:16;71311:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;71436:12;;71420:5;:12;71401:16;:31;;;;:::i;:::-;:47;;71393:91;;;;;;;;;;;;:::i;:::-;;;;;;;;;71500:9;71495:90;71519:5;:12;71515:1;:16;71495:90;;;71553:19;71563:5;71569:1;71563:8;;;;;;;;:::i;:::-;;;;;;;;71553:9;:19::i;:::-;71533:3;;;;;:::i;:::-;;;;71495:90;;;;71240:352;71179:413:::0;:::o;57024:224::-;57126:4;57165:35;57150:50;;;:11;:50;;;;:90;;;;57204:36;57228:11;57204:23;:36::i;:::-;57150:90;57143:97;;57024:224;;;:::o;70043:36::-;;;;:::o;72758:226::-;66735:13;:11;:13::i;:::-;72860:1:::1;72851:6;:10;72843:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;72941:5;72934:22;;;72957:10;72969:6;72934:42;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;72758:226:::0;;:::o;40731:100::-;40785:13;40818:5;40811:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40731:100;:::o;42243:171::-;42319:7;42339:23;42354:7;42339:14;:23::i;:::-;42382:15;:24;42398:7;42382:24;;;;;;;;;;;;;;;;;;;;;42375:31;;42243:171;;;:::o;41761:416::-;41842:13;41858:23;41873:7;41858:14;:23::i;:::-;41842:39;;41906:5;41900:11;;:2;:11;;;41892:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;42000:5;41984:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;42009:37;42026:5;42033:12;:10;:12::i;:::-;42009:16;:37::i;:::-;41984:62;41962:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;42148:21;42157:2;42161:7;42148:8;:21::i;:::-;41831:346;41761:416;;:::o;57664:113::-;57725:7;57752:10;:17;;;;57745:24;;57664:113;:::o;42943:335::-;43138:41;43157:12;:10;:12::i;:::-;43171:7;43138:18;:41::i;:::-;43130:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;43242:28;43252:4;43258:2;43262:7;43242:9;:28::i;:::-;42943:335;;;:::o;71902:98::-;66735:13;:11;:13::i;:::-;71960:8:::1;:6;:8::i;:::-;:32;;71984:8;:6;:8::i;:::-;71960:32;;;71971:10;:8;:10::i;:::-;71960:32;71902:98::o:0;57332:256::-;57429:7;57465:23;57482:5;57465:16;:23::i;:::-;57457:5;:31;57449:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;57554:12;:19;57567:5;57554:19;;;;;;;;;;;;;;;:26;57574:5;57554:26;;;;;;;;;;;;57547:33;;57332:256;;;;:::o;72506:244::-;66735:13;:11;:13::i;:::-;72588:1:::1;72564:21;:25;72556:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;72655:15;72673:21;72655:39;;72713:10;72705:28;;:37;72734:7;72705:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;72545:205;72506:244::o:0;43349:185::-;43487:39;43504:4;43510:2;43514:7;43487:39;;;;;;;;;;;;:16;:39::i;:::-;43349:185;;;:::o;57854:233::-;57929:7;57965:30;:28;:30::i;:::-;57957:5;:38;57949:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;58062:10;58073:5;58062:17;;;;;;;;:::i;:::-;;;;;;;;;;58055:24;;57854:233;;;:::o;71600:93::-;66735:13;:11;:13::i;:::-;71681:4:::1;71668:10;:17;;;;;;;;;;;;:::i;:::-;;71600:93:::0;:::o;64632:86::-;64679:4;64703:7;;;;;;;;;;;64696:14;;64632:86;:::o;40441:223::-;40513:7;40533:13;40549:17;40558:7;40549:8;:17::i;:::-;40533:33;;40602:1;40585:19;;:5;:19;;;40577:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;40651:5;40644:12;;;40441:223;;;:::o;72196:198::-;66735:13;:11;:13::i;:::-;72292:1:::1;72280:9;:13;72272:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;72377:9;72362:12;:24;;;;72196:198:::0;:::o;40172:207::-;40244:7;40289:1;40272:19;;:5;:19;;;40264:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;40355:9;:16;40365:5;40355:16;;;;;;;;;;;;;;;;40348:23;;40172:207;;;:::o;67497:103::-;66735:13;:11;:13::i;:::-;67562:30:::1;67589:1;67562:18;:30::i;:::-;67497:103::o:0;71701:193::-;71773:39;71792:10;71804:7;71773:18;:39::i;:::-;71765:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;71872:14;71878:7;71872:5;:14::i;:::-;71701:193;:::o;72406:92::-;66735:13;:11;:13::i;:::-;72486:4:::1;72474:9;:16;;;;72406:92:::0;:::o;72008:180::-;66735:13;:11;:13::i;:::-;72096:1:::1;72085:8;:12;72077:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;72171:8;72158:10;:21;;;;72008:180:::0;:::o;66849:87::-;66895:7;66922:6;;;;;;;;;;;66915:13;;66849:87;:::o;70154:24::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;40900:104::-;40956:13;40989:7;40982:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40900:104;:::o;70277:618::-;64237:19;:17;:19::i;:::-;70367:9:::1;;70357:6;:19;;70349:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;70442:24;70469:22;:12;:20;:22::i;:::-;70442:49;;70529:12;;70510:16;:31;70502:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;70620:12;;70610:6;70591:16;:25;;;;:::i;:::-;:41;;70583:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;70729:10;;70720:6;:19;;;;:::i;:::-;70707:9;:32;70699:91;;;;;;;;;;;;:::i;:::-;;;;;;;;;70808:9;70803:85;70827:6;70823:1;:10;70803:85;;;70855:21;70865:10;70855:9;:21::i;:::-;70835:3;;;;;:::i;:::-;;;;70803:85;;;;70338:557;70277:618:::0;:::o;42486:155::-;42581:52;42600:12;:10;:12::i;:::-;42614:8;42624;42581:18;:52::i;:::-;42486:155;;:::o;70086:28::-;;;;:::o;43605:322::-;43779:41;43798:12;:10;:12::i;:::-;43812:7;43779:18;:41::i;:::-;43771:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;43881:38;43895:4;43901:2;43905:7;43914:4;43881:13;:38::i;:::-;43605:322;;;;:::o;41075:281::-;41148:13;41174:23;41189:7;41174:14;:23::i;:::-;41210:21;41234:10;:8;:10::i;:::-;41210:34;;41286:1;41268:7;41262:21;:25;:86;;;;;;;;;;;;;;;;;41314:7;41323:18;:7;:16;:18::i;:::-;41297:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;41262:86;41255:93;;;41075:281;;;:::o;70002:34::-;;;;:::o;42712:164::-;42809:4;42833:18;:25;42852:5;42833:25;;;;;;;;;;;;;;;:35;42859:8;42833:35;;;;;;;;;;;;;;;;;;;;;;;;;42826:42;;42712:164;;;;:::o;67755:201::-;66735:13;:11;:13::i;:::-;67864:1:::1;67844:22;;:8;:22;;::::0;67836:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;67920:28;67939:8;67920:18;:28::i;:::-;67755:201:::0;:::o;67014:132::-;67089:12;:10;:12::i;:::-;67078:23;;:7;:5;:7::i;:::-;:23;;;67070:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67014:132::o;69186:114::-;69251:7;69278;:14;;;69271:21;;69186:114;;;:::o;70903:157::-;70954:24;:12;:22;:24::i;:::-;70989:10;71002:22;:12;:20;:22::i;:::-;70989:35;;71035:17;71045:2;71049;71035:9;:17::i;:::-;70943:117;70903:157;:::o;39803:305::-;39905:4;39957:25;39942:40;;;:11;:40;;;;:105;;;;40014:33;39999:48;;;:11;:48;;;;39942:105;:158;;;;40064:36;40088:11;40064:23;:36::i;:::-;39942:158;39922:178;;39803:305;;;:::o;52062:135::-;52144:16;52152:7;52144;:16::i;:::-;52136:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;52062:135;:::o;38182:98::-;38235:7;38262:10;38255:17;;38182:98;:::o;51341:174::-;51443:2;51416:15;:24;51432:7;51416:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;51499:7;51495:2;51461:46;;51470:23;51485:7;51470:14;:23::i;:::-;51461:46;;;;;;;;;;;;51341:174;;:::o;45960:264::-;46053:4;46070:13;46086:23;46101:7;46086:14;:23::i;:::-;46070:39;;46139:5;46128:16;;:7;:16;;;:52;;;;46148:32;46165:5;46172:7;46148:16;:32::i;:::-;46128:52;:87;;;;46208:7;46184:31;;:20;46196:7;46184:11;:20::i;:::-;:31;;;46128:87;46120:96;;;45960:264;;;;:::o;49959:1263::-;50118:4;50091:31;;:23;50106:7;50091:14;:23::i;:::-;:31;;;50083:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;50197:1;50183:16;;:2;:16;;;50175:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;50253:42;50274:4;50280:2;50284:7;50293:1;50253:20;:42::i;:::-;50425:4;50398:31;;:23;50413:7;50398:14;:23::i;:::-;:31;;;50390:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;50543:15;:24;50559:7;50543:24;;;;;;;;;;;;50536:31;;;;;;;;;;;51038:1;51019:9;:15;51029:4;51019:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;51071:1;51054:9;:13;51064:2;51054:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;51113:2;51094:7;:16;51102:7;51094:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;51152:7;51148:2;51133:27;;51142:4;51133:27;;;;;;;;;;;;51173:41;51193:4;51199:2;51203:7;51212:1;51173:19;:41::i;:::-;49959:1263;;;:::o;65228:118::-;64237:19;:17;:19::i;:::-;65298:4:::1;65288:7;;:14;;;;;;;;;;;;;;;;;;65318:20;65325:12;:10;:12::i;:::-;65318:20;;;;;;:::i;:::-;;;;;;;;65228:118::o:0;65487:120::-;64496:16;:14;:16::i;:::-;65556:5:::1;65546:7;;:15;;;;;;;;;;;;;;;;;;65577:22;65586:12;:10;:12::i;:::-;65577:22;;;;;;:::i;:::-;;;;;;;;65487:120::o:0;45235:117::-;45301:7;45328;:16;45336:7;45328:16;;;;;;;;;;;;;;;;;;;;;45321:23;;45235:117;;;:::o;68116:191::-;68190:16;68209:6;;;;;;;;;;;68190:25;;68235:8;68226:6;;:17;;;;;;;;;;;;;;;;;;68290:8;68259:40;;68280:8;68259:40;;;;;;;;;;;;68179:128;68116:191;:::o;48839:783::-;48899:13;48915:23;48930:7;48915:14;:23::i;:::-;48899:39;;48951:51;48972:5;48987:1;48991:7;49000:1;48951:20;:51::i;:::-;49115:23;49130:7;49115:14;:23::i;:::-;49107:31;;49186:15;:24;49202:7;49186:24;;;;;;;;;;;;49179:31;;;;;;;;;;;49451:1;49431:9;:16;49441:5;49431:16;;;;;;;;;;;;;;;;:21;;;;;;;;;;;49481:7;:16;49489:7;49481:16;;;;;;;;;;;;49474:23;;;;;;;;;;;49543:7;49539:1;49515:36;;49524:5;49515:36;;;;;;;;;;;;49564:50;49584:5;49599:1;49603:7;49612:1;49564:19;:50::i;:::-;48888:734;48839:783;:::o;64791:108::-;64862:8;:6;:8::i;:::-;64861:9;64853:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;64791:108::o;51658:315::-;51813:8;51804:17;;:5;:17;;;51796:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;51900:8;51862:18;:25;51881:5;51862:25;;;;;;;;;;;;;;;:35;51888:8;51862:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;51946:8;51924:41;;51939:5;51924:41;;;51956:8;51924:41;;;;;;:::i;:::-;;;;;;;;51658:315;;;:::o;44808:313::-;44964:28;44974:4;44980:2;44984:7;44964:9;:28::i;:::-;45011:47;45034:4;45040:2;45044:7;45053:4;45011:22;:47::i;:::-;45003:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;44808:313;;;;:::o;71068:103::-;71120:13;71153:10;71146:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71068:103;:::o;16184:716::-;16240:13;16291:14;16328:1;16308:17;16319:5;16308:10;:17::i;:::-;:21;16291:38;;16344:20;16378:6;16367:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16344:41;;16400:11;16529:6;16525:2;16521:15;16513:6;16509:28;16502:35;;16566:288;16573:4;16566:288;;;16598:5;;;;;;;;16740:8;16735:2;16728:5;16724:14;16719:30;16714:3;16706:44;16796:2;16787:11;;;;;;:::i;:::-;;;;;16830:1;16821:5;:10;16566:288;16817:21;16566:288;16875:6;16868:13;;;;;16184:716;;;:::o;69308:127::-;69415:1;69397:7;:14;;;:19;;;;;;;;;;;69308:127;:::o;46566:110::-;46642:26;46652:2;46656:7;46642:26;;;;;;;;;;;;:9;:26::i;:::-;46566:110;;:::o;30342:157::-;30427:4;30466:25;30451:40;;;:11;:40;;;;30444:47;;30342:157;;;:::o;45665:128::-;45730:4;45783:1;45754:31;;:17;45763:7;45754:8;:17::i;:::-;:31;;;;45747:38;;45665:128;;;:::o;58161:915::-;58338:61;58365:4;58371:2;58375:12;58389:9;58338:26;:61::i;:::-;58428:1;58416:9;:13;58412:222;;;58559:63;;;;;;;;;;:::i;:::-;;;;;;;;58412:222;58646:15;58664:12;58646:30;;58709:1;58693:18;;:4;:18;;;58689:187;;58728:40;58760:7;58728:31;:40::i;:::-;58689:187;;;58798:2;58790:10;;:4;:10;;;58786:90;;58817:47;58850:4;58856:7;58817:32;:47::i;:::-;58786:90;58689:187;58904:1;58890:16;;:2;:16;;;58886:183;;58923:45;58960:7;58923:36;:45::i;:::-;58886:183;;;58996:4;58990:10;;:2;:10;;;58986:83;;59017:40;59045:2;59049:7;59017:27;:40::i;:::-;58986:83;58886:183;58327:749;58161:915;;;;:::o;55227:158::-;;;;;:::o;64976:108::-;65043:8;:6;:8::i;:::-;65035:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;64976:108::o;52761:853::-;52915:4;52936:15;:2;:13;;;:15::i;:::-;52932:675;;;52988:2;52972:36;;;53009:12;:10;:12::i;:::-;53023:4;53029:7;53038:4;52972:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;52968:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53230:1;53213:6;:13;:18;53209:328;;53256:60;;;;;;;;;;:::i;:::-;;;;;;;;53209:328;53487:6;53481:13;53472:6;53468:2;53464:15;53457:38;52968:584;53104:41;;;53094:51;;;:6;:51;;;;53087:58;;;;;52932:675;53591:4;53584:11;;52761:853;;;;;;;:::o;13050:922::-;13103:7;13123:14;13140:1;13123:18;;13190:6;13181:5;:15;13177:102;;13226:6;13217:15;;;;;;:::i;:::-;;;;;13261:2;13251:12;;;;13177:102;13306:6;13297:5;:15;13293:102;;13342:6;13333:15;;;;;;:::i;:::-;;;;;13377:2;13367:12;;;;13293:102;13422:6;13413:5;:15;13409:102;;13458:6;13449:15;;;;;;:::i;:::-;;;;;13493:2;13483:12;;;;13409:102;13538:5;13529;:14;13525:99;;13573:5;13564:14;;;;;;:::i;:::-;;;;;13607:1;13597:11;;;;13525:99;13651:5;13642;:14;13638:99;;13686:5;13677:14;;;;;;:::i;:::-;;;;;13720:1;13710:11;;;;13638:99;13764:5;13755;:14;13751:99;;13799:5;13790:14;;;;;;:::i;:::-;;;;;13833:1;13823:11;;;;13751:99;13877:5;13868;:14;13864:66;;13913:1;13903:11;;;;13864:66;13958:6;13951:13;;;13050:922;;;:::o;46903:319::-;47032:18;47038:2;47042:7;47032:5;:18::i;:::-;47083:53;47114:1;47118:2;47122:7;47131:4;47083:22;:53::i;:::-;47061:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;46903:319;;;:::o;54346:159::-;;;;;:::o;59799:164::-;59903:10;:17;;;;59876:15;:24;59892:7;59876:24;;;;;;;;;;;:44;;;;59931:10;59947:7;59931:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59799:164;:::o;60590:988::-;60856:22;60906:1;60881:22;60898:4;60881:16;:22::i;:::-;:26;;;;:::i;:::-;60856:51;;60918:18;60939:17;:26;60957:7;60939:26;;;;;;;;;;;;60918:47;;61086:14;61072:10;:28;61068:328;;61117:19;61139:12;:18;61152:4;61139:18;;;;;;;;;;;;;;;:34;61158:14;61139:34;;;;;;;;;;;;61117:56;;61223:11;61190:12;:18;61203:4;61190:18;;;;;;;;;;;;;;;:30;61209:10;61190:30;;;;;;;;;;;:44;;;;61340:10;61307:17;:30;61325:11;61307:30;;;;;;;;;;;:43;;;;61102:294;61068:328;61492:17;:26;61510:7;61492:26;;;;;;;;;;;61485:33;;;61536:12;:18;61549:4;61536:18;;;;;;;;;;;;;;;:34;61555:14;61536:34;;;;;;;;;;;61529:41;;;60671:907;;60590:988;;:::o;61873:1079::-;62126:22;62171:1;62151:10;:17;;;;:21;;;;:::i;:::-;62126:46;;62183:18;62204:15;:24;62220:7;62204:24;;;;;;;;;;;;62183:45;;62555:19;62577:10;62588:14;62577:26;;;;;;;;:::i;:::-;;;;;;;;;;62555:48;;62641:11;62616:10;62627;62616:22;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;62752:10;62721:15;:28;62737:11;62721:28;;;;;;;;;;;:41;;;;62893:15;:24;62909:7;62893:24;;;;;;;;;;;62886:31;;;62928:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;61944:1008;;;61873:1079;:::o;59377:221::-;59462:14;59479:20;59496:2;59479:16;:20::i;:::-;59462:37;;59537:7;59510:12;:16;59523:2;59510:16;;;;;;;;;;;;;;;:24;59527:6;59510:24;;;;;;;;;;;:34;;;;59584:6;59555:17;:26;59573:7;59555:26;;;;;;;;;;;:35;;;;59451:147;59377:221;;:::o;19311:326::-;19371:4;19628:1;19606:7;:19;;;:23;19599:30;;19311:326;;;:::o;47558:942::-;47652:1;47638:16;;:2;:16;;;47630:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;47711:16;47719:7;47711;:16::i;:::-;47710:17;47702:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;47773:48;47802:1;47806:2;47810:7;47819:1;47773:20;:48::i;:::-;47920:16;47928:7;47920;:16::i;:::-;47919:17;47911:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;48335:1;48318:9;:13;48328:2;48318:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;48379:2;48360:7;:16;48368:7;48360:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;48424:7;48420:2;48399:33;;48416:1;48399:33;;;;;;;;;;;;48445:47;48473:1;48477:2;48481:7;48490:1;48445:19;:47::i;:::-;47558:942;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::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:117;443:1;440;433:12;457:102;498:6;549:2;545:7;540:2;533:5;529:14;525:28;515:38;;457:102;;;:::o;565:180::-;613:77;610:1;603:88;710:4;707:1;700:15;734:4;731:1;724:15;751:281;834:27;856:4;834:27;:::i;:::-;826:6;822:40;964:6;952:10;949:22;928:18;916:10;913:34;910:62;907:88;;;975:18;;:::i;:::-;907:88;1015:10;1011:2;1004:22;794:238;751:281;;:::o;1038:129::-;1072:6;1099:20;;:::i;:::-;1089:30;;1128:33;1156:4;1148:6;1128:33;:::i;:::-;1038:129;;;:::o;1173:311::-;1250:4;1340:18;1332:6;1329:30;1326:56;;;1362:18;;:::i;:::-;1326:56;1412:4;1404:6;1400:17;1392:25;;1472:4;1466;1462:15;1454:23;;1173:311;;;:::o;1490:117::-;1599:1;1596;1589:12;1613:126;1650:7;1690:42;1683:5;1679:54;1668:65;;1613:126;;;:::o;1745:96::-;1782:7;1811:24;1829:5;1811:24;:::i;:::-;1800:35;;1745:96;;;:::o;1847:122::-;1920:24;1938:5;1920:24;:::i;:::-;1913:5;1910:35;1900:63;;1959:1;1956;1949:12;1900:63;1847:122;:::o;1975:139::-;2021:5;2059:6;2046:20;2037:29;;2075:33;2102:5;2075:33;:::i;:::-;1975:139;;;;:::o;2137:710::-;2233:5;2258:81;2274:64;2331:6;2274:64;:::i;:::-;2258:81;:::i;:::-;2249:90;;2359:5;2388:6;2381:5;2374:21;2422:4;2415:5;2411:16;2404:23;;2475:4;2467:6;2463:17;2455:6;2451:30;2504:3;2496:6;2493:15;2490:122;;;2523:79;;:::i;:::-;2490:122;2638:6;2621:220;2655:6;2650:3;2647:15;2621:220;;;2730:3;2759:37;2792:3;2780:10;2759:37;:::i;:::-;2754:3;2747:50;2826:4;2821:3;2817:14;2810:21;;2697:144;2681:4;2676:3;2672:14;2665:21;;2621:220;;;2625:21;2239:608;;2137:710;;;;;:::o;2870:370::-;2941:5;2990:3;2983:4;2975:6;2971:17;2967:27;2957:122;;2998:79;;:::i;:::-;2957:122;3115:6;3102:20;3140:94;3230:3;3222:6;3215:4;3207:6;3203:17;3140:94;:::i;:::-;3131:103;;2947:293;2870:370;;;;:::o;3246:539::-;3330:6;3379:2;3367:9;3358:7;3354:23;3350:32;3347:119;;;3385:79;;:::i;:::-;3347:119;3533:1;3522:9;3518:17;3505:31;3563:18;3555:6;3552:30;3549:117;;;3585:79;;:::i;:::-;3549:117;3690:78;3760:7;3751:6;3740:9;3736:22;3690:78;:::i;:::-;3680:88;;3476:302;3246:539;;;;:::o;3791:149::-;3827:7;3867:66;3860:5;3856:78;3845:89;;3791:149;;;:::o;3946:120::-;4018:23;4035:5;4018:23;:::i;:::-;4011:5;4008:34;3998:62;;4056:1;4053;4046:12;3998:62;3946:120;:::o;4072:137::-;4117:5;4155:6;4142:20;4133:29;;4171:32;4197:5;4171:32;:::i;:::-;4072:137;;;;:::o;4215:327::-;4273:6;4322:2;4310:9;4301:7;4297:23;4293:32;4290:119;;;4328:79;;:::i;:::-;4290:119;4448:1;4473:52;4517:7;4508:6;4497:9;4493:22;4473:52;:::i;:::-;4463:62;;4419:116;4215:327;;;;:::o;4548:90::-;4582:7;4625:5;4618:13;4611:21;4600:32;;4548:90;;;:::o;4644:109::-;4725:21;4740:5;4725:21;:::i;:::-;4720:3;4713:34;4644:109;;:::o;4759:210::-;4846:4;4884:2;4873:9;4869:18;4861:26;;4897:65;4959:1;4948:9;4944:17;4935:6;4897:65;:::i;:::-;4759:210;;;;:::o;4975:77::-;5012:7;5041:5;5030:16;;4975:77;;;:::o;5058:118::-;5145:24;5163:5;5145:24;:::i;:::-;5140:3;5133:37;5058:118;;:::o;5182:222::-;5275:4;5313:2;5302:9;5298:18;5290:26;;5326:71;5394:1;5383:9;5379:17;5370:6;5326:71;:::i;:::-;5182:222;;;;:::o;5410:122::-;5483:24;5501:5;5483:24;:::i;:::-;5476:5;5473:35;5463:63;;5522:1;5519;5512:12;5463:63;5410:122;:::o;5538:139::-;5584:5;5622:6;5609:20;5600:29;;5638:33;5665:5;5638:33;:::i;:::-;5538:139;;;;:::o;5683:474::-;5751:6;5759;5808:2;5796:9;5787:7;5783:23;5779:32;5776:119;;;5814:79;;:::i;:::-;5776:119;5934:1;5959:53;6004:7;5995:6;5984:9;5980:22;5959:53;:::i;:::-;5949:63;;5905:117;6061:2;6087:53;6132:7;6123:6;6112:9;6108:22;6087:53;:::i;:::-;6077:63;;6032:118;5683:474;;;;;:::o;6163:99::-;6215:6;6249:5;6243:12;6233:22;;6163:99;;;:::o;6268:169::-;6352:11;6386:6;6381:3;6374:19;6426:4;6421:3;6417:14;6402:29;;6268:169;;;;:::o;6443:307::-;6511:1;6521:113;6535:6;6532:1;6529:13;6521:113;;;6620:1;6615:3;6611:11;6605:18;6601:1;6596:3;6592:11;6585:39;6557:2;6554:1;6550:10;6545:15;;6521:113;;;6652:6;6649:1;6646:13;6643:101;;;6732:1;6723:6;6718:3;6714:16;6707:27;6643:101;6492:258;6443:307;;;:::o;6756:364::-;6844:3;6872:39;6905:5;6872:39;:::i;:::-;6927:71;6991:6;6986:3;6927:71;:::i;:::-;6920:78;;7007:52;7052:6;7047:3;7040:4;7033:5;7029:16;7007:52;:::i;:::-;7084:29;7106:6;7084:29;:::i;:::-;7079:3;7075:39;7068:46;;6848:272;6756:364;;;;:::o;7126:313::-;7239:4;7277:2;7266:9;7262:18;7254:26;;7326:9;7320:4;7316:20;7312:1;7301:9;7297:17;7290:47;7354:78;7427:4;7418:6;7354:78;:::i;:::-;7346:86;;7126:313;;;;:::o;7445:329::-;7504:6;7553:2;7541:9;7532:7;7528:23;7524:32;7521:119;;;7559:79;;:::i;:::-;7521:119;7679:1;7704:53;7749:7;7740:6;7729:9;7725:22;7704:53;:::i;:::-;7694:63;;7650:117;7445:329;;;;:::o;7780:118::-;7867:24;7885:5;7867:24;:::i;:::-;7862:3;7855:37;7780:118;;:::o;7904:222::-;7997:4;8035:2;8024:9;8020:18;8012:26;;8048:71;8116:1;8105:9;8101:17;8092:6;8048:71;:::i;:::-;7904:222;;;;:::o;8132:619::-;8209:6;8217;8225;8274:2;8262:9;8253:7;8249:23;8245:32;8242:119;;;8280:79;;:::i;:::-;8242:119;8400:1;8425:53;8470:7;8461:6;8450:9;8446:22;8425:53;:::i;:::-;8415:63;;8371:117;8527:2;8553:53;8598:7;8589:6;8578:9;8574:22;8553:53;:::i;:::-;8543:63;;8498:118;8655:2;8681:53;8726:7;8717:6;8706:9;8702:22;8681:53;:::i;:::-;8671:63;;8626:118;8132:619;;;;;:::o;8757:117::-;8866:1;8863;8856:12;8880:308;8942:4;9032:18;9024:6;9021:30;9018:56;;;9054:18;;:::i;:::-;9018:56;9092:29;9114:6;9092:29;:::i;:::-;9084:37;;9176:4;9170;9166:15;9158:23;;8880:308;;;:::o;9194:154::-;9278:6;9273:3;9268;9255:30;9340:1;9331:6;9326:3;9322:16;9315:27;9194:154;;;:::o;9354:412::-;9432:5;9457:66;9473:49;9515:6;9473:49;:::i;:::-;9457:66;:::i;:::-;9448:75;;9546:6;9539:5;9532:21;9584:4;9577:5;9573:16;9622:3;9613:6;9608:3;9604:16;9601:25;9598:112;;;9629:79;;:::i;:::-;9598:112;9719:41;9753:6;9748:3;9743;9719:41;:::i;:::-;9438:328;9354:412;;;;;:::o;9786:340::-;9842:5;9891:3;9884:4;9876:6;9872:17;9868:27;9858:122;;9899:79;;:::i;:::-;9858:122;10016:6;10003:20;10041:79;10116:3;10108:6;10101:4;10093:6;10089:17;10041:79;:::i;:::-;10032:88;;9848:278;9786:340;;;;:::o;10132:509::-;10201:6;10250:2;10238:9;10229:7;10225:23;10221:32;10218:119;;;10256:79;;:::i;:::-;10218:119;10404:1;10393:9;10389:17;10376:31;10434:18;10426:6;10423:30;10420:117;;;10456:79;;:::i;:::-;10420:117;10561:63;10616:7;10607:6;10596:9;10592:22;10561:63;:::i;:::-;10551:73;;10347:287;10132:509;;;;:::o;10647:329::-;10706:6;10755:2;10743:9;10734:7;10730:23;10726:32;10723:119;;;10761:79;;:::i;:::-;10723:119;10881:1;10906:53;10951:7;10942:6;10931:9;10927:22;10906:53;:::i;:::-;10896:63;;10852:117;10647:329;;;;:::o;10982:116::-;11052:21;11067:5;11052:21;:::i;:::-;11045:5;11042:32;11032:60;;11088:1;11085;11078:12;11032:60;10982:116;:::o;11104:133::-;11147:5;11185:6;11172:20;11163:29;;11201:30;11225:5;11201:30;:::i;:::-;11104:133;;;;:::o;11243:468::-;11308:6;11316;11365:2;11353:9;11344:7;11340:23;11336:32;11333:119;;;11371:79;;:::i;:::-;11333:119;11491:1;11516:53;11561:7;11552:6;11541:9;11537:22;11516:53;:::i;:::-;11506:63;;11462:117;11618:2;11644:50;11686:7;11677:6;11666:9;11662:22;11644:50;:::i;:::-;11634:60;;11589:115;11243:468;;;;;:::o;11717:307::-;11778:4;11868:18;11860:6;11857:30;11854:56;;;11890:18;;:::i;:::-;11854:56;11928:29;11950:6;11928:29;:::i;:::-;11920:37;;12012:4;12006;12002:15;11994:23;;11717:307;;;:::o;12030:410::-;12107:5;12132:65;12148:48;12189:6;12148:48;:::i;:::-;12132:65;:::i;:::-;12123:74;;12220:6;12213:5;12206:21;12258:4;12251:5;12247:16;12296:3;12287:6;12282:3;12278:16;12275:25;12272:112;;;12303:79;;:::i;:::-;12272:112;12393:41;12427:6;12422:3;12417;12393:41;:::i;:::-;12113:327;12030:410;;;;;:::o;12459:338::-;12514:5;12563:3;12556:4;12548:6;12544:17;12540:27;12530:122;;12571:79;;:::i;:::-;12530:122;12688:6;12675:20;12713:78;12787:3;12779:6;12772:4;12764:6;12760:17;12713:78;:::i;:::-;12704:87;;12520:277;12459:338;;;;:::o;12803:943::-;12898:6;12906;12914;12922;12971:3;12959:9;12950:7;12946:23;12942:33;12939:120;;;12978:79;;:::i;:::-;12939:120;13098:1;13123:53;13168:7;13159:6;13148:9;13144:22;13123:53;:::i;:::-;13113:63;;13069:117;13225:2;13251:53;13296:7;13287:6;13276:9;13272:22;13251:53;:::i;:::-;13241:63;;13196:118;13353:2;13379:53;13424:7;13415:6;13404:9;13400:22;13379:53;:::i;:::-;13369:63;;13324:118;13509:2;13498:9;13494:18;13481:32;13540:18;13532:6;13529:30;13526:117;;;13562:79;;:::i;:::-;13526:117;13667:62;13721:7;13712:6;13701:9;13697:22;13667:62;:::i;:::-;13657:72;;13452:287;12803:943;;;;;;;:::o;13752:474::-;13820:6;13828;13877:2;13865:9;13856:7;13852:23;13848:32;13845:119;;;13883:79;;:::i;:::-;13845:119;14003:1;14028:53;14073:7;14064:6;14053:9;14049:22;14028:53;:::i;:::-;14018:63;;13974:117;14130:2;14156:53;14201:7;14192:6;14181:9;14177:22;14156:53;:::i;:::-;14146:63;;14101:118;13752:474;;;;;:::o;14232:229::-;14372:34;14368:1;14360:6;14356:14;14349:58;14441:12;14436:2;14428:6;14424:15;14417:37;14232:229;:::o;14467:366::-;14609:3;14630:67;14694:2;14689:3;14630:67;:::i;:::-;14623:74;;14706:93;14795:3;14706:93;:::i;:::-;14824:2;14819:3;14815:12;14808:19;;14467:366;;;:::o;14839:419::-;15005:4;15043:2;15032:9;15028:18;15020:26;;15092:9;15086:4;15082:20;15078:1;15067:9;15063:17;15056:47;15120:131;15246:4;15120:131;:::i;:::-;15112:139;;14839:419;;;:::o;15264:180::-;15312:77;15309:1;15302:88;15409:4;15406:1;15399:15;15433:4;15430:1;15423:15;15450:305;15490:3;15509:20;15527:1;15509:20;:::i;:::-;15504:25;;15543:20;15561:1;15543:20;:::i;:::-;15538:25;;15697:1;15629:66;15625:74;15622:1;15619:81;15616:107;;;15703:18;;:::i;:::-;15616:107;15747:1;15744;15740:9;15733:16;;15450:305;;;;:::o;15761:181::-;15901:33;15897:1;15889:6;15885:14;15878:57;15761:181;:::o;15948:366::-;16090:3;16111:67;16175:2;16170:3;16111:67;:::i;:::-;16104:74;;16187:93;16276:3;16187:93;:::i;:::-;16305:2;16300:3;16296:12;16289:19;;15948:366;;;:::o;16320:419::-;16486:4;16524:2;16513:9;16509:18;16501:26;;16573:9;16567:4;16563:20;16559:1;16548:9;16544:17;16537:47;16601:131;16727:4;16601:131;:::i;:::-;16593:139;;16320:419;;;:::o;16745:180::-;16793:77;16790:1;16783:88;16890:4;16887:1;16880:15;16914:4;16911:1;16904:15;16931:233;16970:3;16993:24;17011:5;16993:24;:::i;:::-;16984:33;;17039:66;17032:5;17029:77;17026:103;;17109:18;;:::i;:::-;17026:103;17156:1;17149:5;17145:13;17138:20;;16931:233;;;:::o;17170:244::-;17310:34;17306:1;17298:6;17294:14;17287:58;17379:27;17374:2;17366:6;17362:15;17355:52;17170:244;:::o;17420:366::-;17562:3;17583:67;17647:2;17642:3;17583:67;:::i;:::-;17576:74;;17659:93;17748:3;17659:93;:::i;:::-;17777:2;17772:3;17768:12;17761:19;;17420:366;;;:::o;17792:419::-;17958:4;17996:2;17985:9;17981:18;17973:26;;18045:9;18039:4;18035:20;18031:1;18020:9;18016:17;18009:47;18073:131;18199:4;18073:131;:::i;:::-;18065:139;;17792:419;;;:::o;18217:332::-;18338:4;18376:2;18365:9;18361:18;18353:26;;18389:71;18457:1;18446:9;18442:17;18433:6;18389:71;:::i;:::-;18470:72;18538:2;18527:9;18523:18;18514:6;18470:72;:::i;:::-;18217:332;;;;;:::o;18555:137::-;18609:5;18640:6;18634:13;18625:22;;18656:30;18680:5;18656:30;:::i;:::-;18555:137;;;;:::o;18698:345::-;18765:6;18814:2;18802:9;18793:7;18789:23;18785:32;18782:119;;;18820:79;;:::i;:::-;18782:119;18940:1;18965:61;19018:7;19009:6;18998:9;18994:22;18965:61;:::i;:::-;18955:71;;18911:125;18698:345;;;;:::o;19049:180::-;19097:77;19094:1;19087:88;19194:4;19191:1;19184:15;19218:4;19215:1;19208:15;19235:320;19279:6;19316:1;19310:4;19306:12;19296:22;;19363:1;19357:4;19353:12;19384:18;19374:81;;19440:4;19432:6;19428:17;19418:27;;19374:81;19502:2;19494:6;19491:14;19471:18;19468:38;19465:84;;19521:18;;:::i;:::-;19465:84;19286:269;19235:320;;;:::o;19561:220::-;19701:34;19697:1;19689:6;19685:14;19678:58;19770:3;19765:2;19757:6;19753:15;19746:28;19561:220;:::o;19787:366::-;19929:3;19950:67;20014:2;20009:3;19950:67;:::i;:::-;19943:74;;20026:93;20115:3;20026:93;:::i;:::-;20144:2;20139:3;20135:12;20128:19;;19787:366;;;:::o;20159:419::-;20325:4;20363:2;20352:9;20348:18;20340:26;;20412:9;20406:4;20402:20;20398:1;20387:9;20383:17;20376:47;20440:131;20566:4;20440:131;:::i;:::-;20432:139;;20159:419;;;:::o;20584:248::-;20724:34;20720:1;20712:6;20708:14;20701:58;20793:31;20788:2;20780:6;20776:15;20769:56;20584:248;:::o;20838:366::-;20980:3;21001:67;21065:2;21060:3;21001:67;:::i;:::-;20994:74;;21077:93;21166:3;21077:93;:::i;:::-;21195:2;21190:3;21186:12;21179:19;;20838:366;;;:::o;21210:419::-;21376:4;21414:2;21403:9;21399:18;21391:26;;21463:9;21457:4;21453:20;21449:1;21438:9;21434:17;21427:47;21491:131;21617:4;21491:131;:::i;:::-;21483:139;;21210:419;;;:::o;21635:232::-;21775:34;21771:1;21763:6;21759:14;21752:58;21844:15;21839:2;21831:6;21827:15;21820:40;21635:232;:::o;21873:366::-;22015:3;22036:67;22100:2;22095:3;22036:67;:::i;:::-;22029:74;;22112:93;22201:3;22112:93;:::i;:::-;22230:2;22225:3;22221:12;22214:19;;21873:366;;;:::o;22245:419::-;22411:4;22449:2;22438:9;22434:18;22426:26;;22498:9;22492:4;22488:20;22484:1;22473:9;22469:17;22462:47;22526:131;22652:4;22526:131;:::i;:::-;22518:139;;22245:419;;;:::o;22670:230::-;22810:34;22806:1;22798:6;22794:14;22787:58;22879:13;22874:2;22866:6;22862:15;22855:38;22670:230;:::o;22906:366::-;23048:3;23069:67;23133:2;23128:3;23069:67;:::i;:::-;23062:74;;23145:93;23234:3;23145:93;:::i;:::-;23263:2;23258:3;23254:12;23247:19;;22906:366;;;:::o;23278:419::-;23444:4;23482:2;23471:9;23467:18;23459:26;;23531:9;23525:4;23521:20;23517:1;23506:9;23502:17;23495:47;23559:131;23685:4;23559:131;:::i;:::-;23551:139;;23278:419;;;:::o;23703:236::-;23843:34;23839:1;23831:6;23827:14;23820:58;23912:19;23907:2;23899:6;23895:15;23888:44;23703:236;:::o;23945:366::-;24087:3;24108:67;24172:2;24167:3;24108:67;:::i;:::-;24101:74;;24184:93;24273:3;24184:93;:::i;:::-;24302:2;24297:3;24293:12;24286:19;;23945:366;;;:::o;24317:419::-;24483:4;24521:2;24510:9;24506:18;24498:26;;24570:9;24564:4;24560:20;24556:1;24545:9;24541:17;24534:47;24598:131;24724:4;24598:131;:::i;:::-;24590:139;;24317:419;;;:::o;24742:231::-;24882:34;24878:1;24870:6;24866:14;24859:58;24951:14;24946:2;24938:6;24934:15;24927:39;24742:231;:::o;24979:366::-;25121:3;25142:67;25206:2;25201:3;25142:67;:::i;:::-;25135:74;;25218:93;25307:3;25218:93;:::i;:::-;25336:2;25331:3;25327:12;25320:19;;24979:366;;;:::o;25351:419::-;25517:4;25555:2;25544:9;25540:18;25532:26;;25604:9;25598:4;25594:20;25590:1;25579:9;25575:17;25568:47;25632:131;25758:4;25632:131;:::i;:::-;25624:139;;25351:419;;;:::o;25776:174::-;25916:26;25912:1;25904:6;25900:14;25893:50;25776:174;:::o;25956:366::-;26098:3;26119:67;26183:2;26178:3;26119:67;:::i;:::-;26112:74;;26195:93;26284:3;26195:93;:::i;:::-;26313:2;26308:3;26304:12;26297:19;;25956:366;;;:::o;26328:419::-;26494:4;26532:2;26521:9;26517:18;26509:26;;26581:9;26575:4;26571:20;26567:1;26556:9;26552:17;26545:47;26609:131;26735:4;26609:131;:::i;:::-;26601:139;;26328:419;;;:::o;26753:239::-;26893:34;26889:1;26881:6;26877:14;26870:58;26962:22;26957:2;26949:6;26945:15;26938:47;26753:239;:::o;26998:366::-;27140:3;27161:67;27225:2;27220:3;27161:67;:::i;:::-;27154:74;;27237:93;27326:3;27237:93;:::i;:::-;27355:2;27350:3;27346:12;27339:19;;26998:366;;;:::o;27370:419::-;27536:4;27574:2;27563:9;27559:18;27551:26;;27623:9;27617:4;27613:20;27609:1;27598:9;27594:17;27587:47;27651:131;27777:4;27651:131;:::i;:::-;27643:139;;27370:419;;;:::o;27795:228::-;27935:34;27931:1;27923:6;27919:14;27912:58;28004:11;27999:2;27991:6;27987:15;27980:36;27795:228;:::o;28029:366::-;28171:3;28192:67;28256:2;28251:3;28192:67;:::i;:::-;28185:74;;28268:93;28357:3;28268:93;:::i;:::-;28386:2;28381:3;28377:12;28370:19;;28029:366;;;:::o;28401:419::-;28567:4;28605:2;28594:9;28590:18;28582:26;;28654:9;28648:4;28644:20;28640:1;28629:9;28625:17;28618:47;28682:131;28808:4;28682:131;:::i;:::-;28674:139;;28401:419;;;:::o;28826:230::-;28966:34;28962:1;28954:6;28950:14;28943:58;29035:13;29030:2;29022:6;29018:15;29011:38;28826:230;:::o;29062:366::-;29204:3;29225:67;29289:2;29284:3;29225:67;:::i;:::-;29218:74;;29301:93;29390:3;29301:93;:::i;:::-;29419:2;29414:3;29410:12;29403:19;;29062:366;;;:::o;29434:419::-;29600:4;29638:2;29627:9;29623:18;29615:26;;29687:9;29681:4;29677:20;29673:1;29662:9;29658:17;29651:47;29715:131;29841:4;29715:131;:::i;:::-;29707:139;;29434:419;;;:::o;29859:232::-;29999:34;29995:1;29987:6;29983:14;29976:58;30068:15;30063:2;30055:6;30051:15;30044:40;29859:232;:::o;30097:366::-;30239:3;30260:67;30324:2;30319:3;30260:67;:::i;:::-;30253:74;;30336:93;30425:3;30336:93;:::i;:::-;30454:2;30449:3;30445:12;30438:19;;30097:366;;;:::o;30469:419::-;30635:4;30673:2;30662:9;30658:18;30650:26;;30722:9;30716:4;30712:20;30708:1;30697:9;30693:17;30686:47;30750:131;30876:4;30750:131;:::i;:::-;30742:139;;30469:419;;;:::o;30894:237::-;31034:34;31030:1;31022:6;31018:14;31011:58;31103:20;31098:2;31090:6;31086:15;31079:45;30894:237;:::o;31137:366::-;31279:3;31300:67;31364:2;31359:3;31300:67;:::i;:::-;31293:74;;31376:93;31465:3;31376:93;:::i;:::-;31494:2;31489:3;31485:12;31478:19;;31137:366;;;:::o;31509:419::-;31675:4;31713:2;31702:9;31698:18;31690:26;;31762:9;31756:4;31752:20;31748:1;31737:9;31733:17;31726:47;31790:131;31916:4;31790:131;:::i;:::-;31782:139;;31509:419;;;:::o;31934:176::-;32074:28;32070:1;32062:6;32058:14;32051:52;31934:176;:::o;32116:366::-;32258:3;32279:67;32343:2;32338:3;32279:67;:::i;:::-;32272:74;;32355:93;32444:3;32355:93;:::i;:::-;32473:2;32468:3;32464:12;32457:19;;32116:366;;;:::o;32488:419::-;32654:4;32692:2;32681:9;32677:18;32669:26;;32741:9;32735:4;32731:20;32727:1;32716:9;32712:17;32705:47;32769:131;32895:4;32769:131;:::i;:::-;32761:139;;32488:419;;;:::o;32913:238::-;33053:34;33049:1;33041:6;33037:14;33030:58;33122:21;33117:2;33109:6;33105:15;33098:46;32913:238;:::o;33157:366::-;33299:3;33320:67;33384:2;33379:3;33320:67;:::i;:::-;33313:74;;33396:93;33485:3;33396:93;:::i;:::-;33514:2;33509:3;33505:12;33498:19;;33157:366;;;:::o;33529:419::-;33695:4;33733:2;33722:9;33718:18;33710:26;;33782:9;33776:4;33772:20;33768:1;33757:9;33753:17;33746:47;33810:131;33936:4;33810:131;:::i;:::-;33802:139;;33529:419;;;:::o;33954:348::-;33994:7;34017:20;34035:1;34017:20;:::i;:::-;34012:25;;34051:20;34069:1;34051:20;:::i;:::-;34046:25;;34239:1;34171:66;34167:74;34164:1;34161:81;34156:1;34149:9;34142:17;34138:105;34135:131;;;34246:18;;:::i;:::-;34135:131;34294:1;34291;34287:9;34276:20;;33954:348;;;;:::o;34308:233::-;34448:34;34444:1;34436:6;34432:14;34425:58;34517:16;34512:2;34504:6;34500:15;34493:41;34308:233;:::o;34547:366::-;34689:3;34710:67;34774:2;34769:3;34710:67;:::i;:::-;34703:74;;34786:93;34875:3;34786:93;:::i;:::-;34904:2;34899:3;34895:12;34888:19;;34547:366;;;:::o;34919:419::-;35085:4;35123:2;35112:9;35108:18;35100:26;;35172:9;35166:4;35162:20;35158:1;35147:9;35143:17;35136:47;35200:131;35326:4;35200:131;:::i;:::-;35192:139;;34919:419;;;:::o;35344:148::-;35446:11;35483:3;35468:18;;35344:148;;;;:::o;35498:377::-;35604:3;35632:39;35665:5;35632:39;:::i;:::-;35687:89;35769:6;35764:3;35687:89;:::i;:::-;35680:96;;35785:52;35830:6;35825:3;35818:4;35811:5;35807:16;35785:52;:::i;:::-;35862:6;35857:3;35853:16;35846:23;;35608:267;35498:377;;;;:::o;35881:435::-;36061:3;36083:95;36174:3;36165:6;36083:95;:::i;:::-;36076:102;;36195:95;36286:3;36277:6;36195:95;:::i;:::-;36188:102;;36307:3;36300:10;;35881:435;;;;;:::o;36322:225::-;36462:34;36458:1;36450:6;36446:14;36439:58;36531:8;36526:2;36518:6;36514:15;36507:33;36322:225;:::o;36553:366::-;36695:3;36716:67;36780:2;36775:3;36716:67;:::i;:::-;36709:74;;36792:93;36881:3;36792:93;:::i;:::-;36910:2;36905:3;36901:12;36894:19;;36553:366;;;:::o;36925:419::-;37091:4;37129:2;37118:9;37114:18;37106:26;;37178:9;37172:4;37168:20;37164:1;37153:9;37149:17;37142:47;37206:131;37332:4;37206:131;:::i;:::-;37198:139;;36925:419;;;:::o;37350:182::-;37490:34;37486:1;37478:6;37474:14;37467:58;37350:182;:::o;37538:366::-;37680:3;37701:67;37765:2;37760:3;37701:67;:::i;:::-;37694:74;;37777:93;37866:3;37777:93;:::i;:::-;37895:2;37890:3;37886:12;37879:19;;37538:366;;;:::o;37910:419::-;38076:4;38114:2;38103:9;38099:18;38091:26;;38163:9;38157:4;38153:20;38149:1;38138:9;38134:17;38127:47;38191:131;38317:4;38191:131;:::i;:::-;38183:139;;37910:419;;;:::o;38335:224::-;38475:34;38471:1;38463:6;38459:14;38452:58;38544:7;38539:2;38531:6;38527:15;38520:32;38335:224;:::o;38565:366::-;38707:3;38728:67;38792:2;38787:3;38728:67;:::i;:::-;38721:74;;38804:93;38893:3;38804:93;:::i;:::-;38922:2;38917:3;38913:12;38906:19;;38565:366;;;:::o;38937:419::-;39103:4;39141:2;39130:9;39126:18;39118:26;;39190:9;39184:4;39180:20;39176:1;39165:9;39161:17;39154:47;39218:131;39344:4;39218:131;:::i;:::-;39210:139;;38937:419;;;:::o;39362:223::-;39502:34;39498:1;39490:6;39486:14;39479:58;39571:6;39566:2;39558:6;39554:15;39547:31;39362:223;:::o;39591:366::-;39733:3;39754:67;39818:2;39813:3;39754:67;:::i;:::-;39747:74;;39830:93;39919:3;39830:93;:::i;:::-;39948:2;39943:3;39939:12;39932:19;;39591:366;;;:::o;39963:419::-;40129:4;40167:2;40156:9;40152:18;40144:26;;40216:9;40210:4;40206:20;40202:1;40191:9;40187:17;40180:47;40244:131;40370:4;40244:131;:::i;:::-;40236:139;;39963:419;;;:::o;40388:166::-;40528:18;40524:1;40516:6;40512:14;40505:42;40388:166;:::o;40560:366::-;40702:3;40723:67;40787:2;40782:3;40723:67;:::i;:::-;40716:74;;40799:93;40888:3;40799:93;:::i;:::-;40917:2;40912:3;40908:12;40901:19;;40560:366;;;:::o;40932:419::-;41098:4;41136:2;41125:9;41121:18;41113:26;;41185:9;41179:4;41175:20;41171:1;41160:9;41156:17;41149:47;41213:131;41339:4;41213:131;:::i;:::-;41205:139;;40932:419;;;:::o;41357:175::-;41497:27;41493:1;41485:6;41481:14;41474:51;41357:175;:::o;41538:366::-;41680:3;41701:67;41765:2;41760:3;41701:67;:::i;:::-;41694:74;;41777:93;41866:3;41777:93;:::i;:::-;41895:2;41890:3;41886:12;41879:19;;41538:366;;;:::o;41910:419::-;42076:4;42114:2;42103:9;42099:18;42091:26;;42163:9;42157:4;42153:20;42149:1;42138:9;42134:17;42127:47;42191:131;42317:4;42191:131;:::i;:::-;42183:139;;41910:419;;;:::o;42335:237::-;42475:34;42471:1;42463:6;42459:14;42452:58;42544:20;42539:2;42531:6;42527:15;42520:45;42335:237;:::o;42578:366::-;42720:3;42741:67;42805:2;42800:3;42741:67;:::i;:::-;42734:74;;42817:93;42906:3;42817:93;:::i;:::-;42935:2;42930:3;42926:12;42919:19;;42578:366;;;:::o;42950:419::-;43116:4;43154:2;43143:9;43139:18;43131:26;;43203:9;43197:4;43193:20;43189:1;43178:9;43174:17;43167:47;43231:131;43357:4;43231:131;:::i;:::-;43223:139;;42950:419;;;:::o;43375:180::-;43423:77;43420:1;43413:88;43520:4;43517:1;43510:15;43544:4;43541:1;43534:15;43561:240;43701:34;43697:1;43689:6;43685:14;43678:58;43770:23;43765:2;43757:6;43753:15;43746:48;43561:240;:::o;43807:366::-;43949:3;43970:67;44034:2;44029:3;43970:67;:::i;:::-;43963:74;;44046:93;44135:3;44046:93;:::i;:::-;44164:2;44159:3;44155:12;44148:19;;43807:366;;;:::o;44179:419::-;44345:4;44383:2;44372:9;44368:18;44360:26;;44432:9;44426:4;44422:20;44418:1;44407:9;44403:17;44396:47;44460:131;44586:4;44460:131;:::i;:::-;44452:139;;44179:419;;;:::o;44604:170::-;44744:22;44740:1;44732:6;44728:14;44721:46;44604:170;:::o;44780:366::-;44922:3;44943:67;45007:2;45002:3;44943:67;:::i;:::-;44936:74;;45019:93;45108:3;45019:93;:::i;:::-;45137:2;45132:3;45128:12;45121:19;;44780:366;;;:::o;45152:419::-;45318:4;45356:2;45345:9;45341:18;45333:26;;45405:9;45399:4;45395:20;45391:1;45380:9;45376:17;45369:47;45433:131;45559:4;45433:131;:::i;:::-;45425:139;;45152:419;;;:::o;45577:98::-;45628:6;45662:5;45656:12;45646:22;;45577:98;;;:::o;45681:168::-;45764:11;45798:6;45793:3;45786:19;45838:4;45833:3;45829:14;45814:29;;45681:168;;;;:::o;45855:360::-;45941:3;45969:38;46001:5;45969:38;:::i;:::-;46023:70;46086:6;46081:3;46023:70;:::i;:::-;46016:77;;46102:52;46147:6;46142:3;46135:4;46128:5;46124:16;46102:52;:::i;:::-;46179:29;46201:6;46179:29;:::i;:::-;46174:3;46170:39;46163:46;;45945:270;45855:360;;;;:::o;46221:640::-;46416:4;46454:3;46443:9;46439:19;46431:27;;46468:71;46536:1;46525:9;46521:17;46512:6;46468:71;:::i;:::-;46549:72;46617:2;46606:9;46602:18;46593:6;46549:72;:::i;:::-;46631;46699:2;46688:9;46684:18;46675:6;46631:72;:::i;:::-;46750:9;46744:4;46740:20;46735:2;46724:9;46720:18;46713:48;46778:76;46849:4;46840:6;46778:76;:::i;:::-;46770:84;;46221:640;;;;;;;:::o;46867:141::-;46923:5;46954:6;46948:13;46939:22;;46970:32;46996:5;46970:32;:::i;:::-;46867:141;;;;:::o;47014:349::-;47083:6;47132:2;47120:9;47111:7;47107:23;47103:32;47100:119;;;47138:79;;:::i;:::-;47100:119;47258:1;47283:63;47338:7;47329:6;47318:9;47314:22;47283:63;:::i;:::-;47273:73;;47229:127;47014:349;;;;:::o;47369:191::-;47409:4;47429:20;47447:1;47429:20;:::i;:::-;47424:25;;47463:20;47481:1;47463:20;:::i;:::-;47458:25;;47502:1;47499;47496:8;47493:34;;;47507:18;;:::i;:::-;47493:34;47552:1;47549;47545:9;47537:17;;47369:191;;;;:::o;47566:180::-;47614:77;47611:1;47604:88;47711:4;47708:1;47701:15;47735:4;47732:1;47725:15;47752:182;47892:34;47888:1;47880:6;47876:14;47869:58;47752:182;:::o;47940:366::-;48082:3;48103:67;48167:2;48162:3;48103:67;:::i;:::-;48096:74;;48179:93;48268:3;48179:93;:::i;:::-;48297:2;48292:3;48288:12;48281:19;;47940:366;;;:::o;48312:419::-;48478:4;48516:2;48505:9;48501:18;48493:26;;48565:9;48559:4;48555:20;48551:1;48540:9;48536:17;48529:47;48593:131;48719:4;48593:131;:::i;:::-;48585:139;;48312:419;;;:::o;48737:178::-;48877:30;48873:1;48865:6;48861:14;48854:54;48737:178;:::o;48921:366::-;49063:3;49084:67;49148:2;49143:3;49084:67;:::i;:::-;49077:74;;49160:93;49249:3;49160:93;:::i;:::-;49278:2;49273:3;49269:12;49262:19;;48921:366;;;:::o;49293:419::-;49459:4;49497:2;49486:9;49482:18;49474:26;;49546:9;49540:4;49536:20;49532:1;49521:9;49517:17;49510:47;49574:131;49700:4;49574:131;:::i;:::-;49566:139;;49293:419;;;:::o

ipfs://c67b15233d42d1a931d3947fc97174512cdafeb1156db5871889019e772afc75