Token Web3Space

Overview

TokenID:
5

Transfers:
-

Loading
[ Download CSV Export  ] 
Loading
Loading

Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Smartnft_Pro_ERC721

Compiler Version
v0.8.13+commit.abaa5c0e

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at bttcscan.com on 2023-10-08
*/

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.13;

/**
 * @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/utils/math/[email protected]
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

/**
 * @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/[email protected]
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)



/**
 * @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/token/ERC721/[email protected]
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)


/**
 * @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/[email protected]
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)


/**
 * @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/utils/introspection/[email protected]
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)


/**
 * @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/[email protected]
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)


/**
 * @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/[email protected]
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)


/**
 * @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/[email protected]


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



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

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

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


// File @openzeppelin/contracts/token/ERC721/[email protected]

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








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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

        _owners[tokenId] = to;

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

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

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

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

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

        // Clear approvals
        delete _tokenApprovals[tokenId];

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId, 1);

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

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

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

        emit Transfer(from, to, tokenId);

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

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721URIStorage.sol)


/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

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

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev See {ERC721-_burn}. This override additionally checks to see if a
     * token-specific URI was set for the token, and if so, it deletes the token URI from
     * the storage mapping.
     */
    function _burn(uint256 tokenId) internal virtual override {
        super._burn(tokenId);

        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)


/**
 * @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/[email protected]

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



/**
 * @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 contracts/Erc721.sol




contract Smartnft_Pro_ERC721 is  ERC721, ERC721Enumerable, ERC721URIStorage {
  address private _contract_owner;
  uint256 public tokenIds;

  constructor( string memory _name, string memory _symbol ) ERC721( _name, _symbol ) {
      _contract_owner = msg.sender;
  }

  function _beforeTokenTransfer(
    address from, 
    address to, 
    uint256 tokenId, 
    uint256 batchSize
  )internal override(ERC721, ERC721Enumerable)
  {
      super._beforeTokenTransfer(from, to, tokenId, batchSize);
  }

  function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
      super._burn(tokenId);
  }

  function tokenURI(uint256 tokenId)
    public
    view
    override(ERC721, ERC721URIStorage)
    returns (string memory)
  {
    return super.tokenURI(tokenId);
  }

  function supportsInterface(bytes4 interfaceId)
    public
    view
    override(ERC721, ERC721Enumerable)
    returns (bool)
  {
    return super.supportsInterface(interfaceId);
  }

  function mint( string memory tokenUri ) public payable returns ( uint256 ) {
     tokenIds++; 
     uint256 newTokenId = tokenIds;
     //`_safeMint, _setTokenURI` fn is comming from ERC721 contract that we extend. 
	   _safeMint(msg.sender, newTokenId);
	   _setTokenURI( newTokenId,tokenUri );

     return newTokenId;
  }

  function gift_mint( string memory tokenUri, address owner ) public payable returns ( uint256 ) {
     tokenIds++; 
     uint256 newTokenId = tokenIds;
     //`_safeMint, _setTokenURI` fn is comming from ERC721 contract that we extend. 
	   _safeMint(owner, newTokenId);
	   _setTokenURI( newTokenId,tokenUri );

     return newTokenId;
  }

  function burn( uint256 tokenId ) public {
    require(
      msg.sender == ownerOf( tokenId ) &&
      _exists( tokenId ) ,
      "Not owner or not exists."
    );

    _burn( tokenId );
  }

	function withdrawBalance() public returns( bool ) {
		require(
			msg.sender == _contract_owner,
			"Not admin"
		);

		uint _balance = address(this).balance;
		
		payable( _contract_owner ).transfer( _balance );

    return true;
	}

	function getBalance () public view returns ( uint ) {
			return address(this).balance;
	}

}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"}],"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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","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":[],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"tokenUri","type":"string"},{"internalType":"address","name":"owner","type":"address"}],"name":"gift_mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","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":"string","name":"tokenUri","type":"string"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenIds","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":[],"name":"withdrawBalance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000009576562335370616365000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055370616365000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Web3Space
Arg [1] : _symbol (string): Space

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [3] : 5765623353706163650000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [5] : 5370616365000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

61444:2250:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62261:188;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36557:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38069:171;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37587:416;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63598:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56109:113;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38769:335;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62793:347;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55777:256;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39175:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63146:198;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56299:233;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63349:244;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36267:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35998:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61561:23;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36726:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38312:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39431:322;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62083:172;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62455:332;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38538:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62261:188;62384:4;62407:36;62431:11;62407:23;:36::i;:::-;62400:43;;62261:188;;;:::o;36557:100::-;36611:13;36644:5;36637:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36557:100;:::o;38069:171::-;38145:7;38165:23;38180:7;38165:14;:23::i;:::-;38208:15;:24;38224:7;38208:24;;;;;;;;;;;;;;;;;;;;;38201:31;;38069:171;;;:::o;37587:416::-;37668:13;37684:23;37699:7;37684:14;:23::i;:::-;37668:39;;37732:5;37726:11;;:2;:11;;;37718:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;37826:5;37810:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;37835:37;37852:5;37859:12;:10;:12::i;:::-;37835:16;:37::i;:::-;37810:62;37788:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;37974:21;37983:2;37987:7;37974:8;:21::i;:::-;37657:346;37587:416;;:::o;63598:91::-;63643:4;63663:21;63656:28;;63598:91;:::o;56109:113::-;56170:7;56197:10;:17;;;;56190:24;;56109:113;:::o;38769:335::-;38964:41;38983:12;:10;:12::i;:::-;38997:7;38964:18;:41::i;:::-;38956:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;39068:28;39078:4;39084:2;39088:7;39068:9;:28::i;:::-;38769:335;;;:::o;62793:347::-;62878:7;62896:8;;:10;;;;;;;;;:::i;:::-;;;;;;62915:18;62936:8;;62915:29;;63037:28;63047:5;63054:10;63037:9;:28::i;:::-;63072:35;63086:10;63097:8;63072:12;:35::i;:::-;63124:10;63117:17;;;62793:347;;;;:::o;55777:256::-;55874:7;55910:23;55927:5;55910:16;:23::i;:::-;55902:5;:31;55894:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;55999:12;:19;56012:5;55999:19;;;;;;;;;;;;;;;:26;56019:5;55999:26;;;;;;;;;;;;55992:33;;55777:256;;;;:::o;39175:185::-;39313:39;39330:4;39336:2;39340:7;39313:39;;;;;;;;;;;;:16;:39::i;:::-;39175:185;;;:::o;63146:198::-;63223:18;63232:7;63223;:18::i;:::-;63209:32;;:10;:32;;;:61;;;;;63252:18;63261:7;63252;:18::i;:::-;63209:61;63193:120;;;;;;;;;;;;:::i;:::-;;;;;;;;;63322:16;63329:7;63322:5;:16::i;:::-;63146:198;:::o;56299:233::-;56374:7;56410:30;:28;:30::i;:::-;56402:5;:38;56394:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;56507:10;56518:5;56507:17;;;;;;;;:::i;:::-;;;;;;;;;;56500:24;;56299:233;;;:::o;63349:244::-;63392:4;63431:15;;;;;;;;;;;63417:29;;:10;:29;;;63404:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;63475:13;63491:21;63475:37;;63530:15;;;;;;;;;;;63521:35;;:47;63558:8;63521:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63584:4;63577:11;;;63349:244;:::o;36267:223::-;36339:7;36359:13;36375:17;36384:7;36375:8;:17::i;:::-;36359:33;;36428:1;36411:19;;:5;:19;;;36403:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;36477:5;36470:12;;;36267:223;;;:::o;35998:207::-;36070:7;36115:1;36098:19;;:5;:19;;;36090:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;36181:9;:16;36191:5;36181:16;;;;;;;;;;;;;;;;36174:23;;35998:207;;;:::o;61561:23::-;;;;:::o;36726:104::-;36782:13;36815:7;36808:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36726:104;:::o;38312:155::-;38407:52;38426:12;:10;:12::i;:::-;38440:8;38450;38407:18;:52::i;:::-;38312:155;;:::o;39431:322::-;39605:41;39624:12;:10;:12::i;:::-;39638:7;39605:18;:41::i;:::-;39597:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;39707:38;39721:4;39727:2;39731:7;39740:4;39707:13;:38::i;:::-;39431:322;;;;:::o;62083:172::-;62194:13;62226:23;62241:7;62226:14;:23::i;:::-;62219:30;;62083:172;;;:::o;62455:332::-;62520:7;62538:8;;:10;;;;;;;;;:::i;:::-;;;;;;62557:18;62578:8;;62557:29;;62679:33;62689:10;62701;62679:9;:33::i;:::-;62719:35;62733:10;62744:8;62719:12;:35::i;:::-;62771:10;62764:17;;;62455:332;;;:::o;38538:164::-;38635:4;38659:18;:25;38678:5;38659:25;;;;;;;;;;;;;;;:35;38685:8;38659:35;;;;;;;;;;;;;;;;;;;;;;;;;38652:42;;38538:164;;;;:::o;55469:224::-;55571:4;55610:35;55595:50;;;:11;:50;;;;:90;;;;55649:36;55673:11;55649:23;:36::i;:::-;55595:90;55588:97;;55469:224;;;:::o;47888:135::-;47970:16;47978:7;47970;:16::i;:::-;47962:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;47888:135;:::o;655:98::-;708:7;735:10;728:17;;655:98;:::o;47167:174::-;47269:2;47242:15;:24;47258:7;47242:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;47325:7;47321:2;47287:46;;47296:23;47311:7;47296:14;:23::i;:::-;47287:46;;;;;;;;;;;;47167:174;;:::o;41786:264::-;41879:4;41896:13;41912:23;41927:7;41912:14;:23::i;:::-;41896:39;;41965:5;41954:16;;:7;:16;;;:52;;;;41974:32;41991:5;41998:7;41974:16;:32::i;:::-;41954:52;:87;;;;42034:7;42010:31;;:20;42022:7;42010:11;:20::i;:::-;:31;;;41954:87;41946:96;;;41786:264;;;;:::o;45785:1263::-;45944:4;45917:31;;:23;45932:7;45917:14;:23::i;:::-;:31;;;45909:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;46023:1;46009:16;;:2;:16;;;46001:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;46079:42;46100:4;46106:2;46110:7;46119:1;46079:20;:42::i;:::-;46251:4;46224:31;;:23;46239:7;46224:14;:23::i;:::-;:31;;;46216:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;46369:15;:24;46385:7;46369:24;;;;;;;;;;;;46362:31;;;;;;;;;;;46864:1;46845:9;:15;46855:4;46845:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;46897:1;46880:9;:13;46890:2;46880:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;46939:2;46920:7;:16;46928:7;46920:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;46978:7;46974:2;46959:27;;46968:4;46959:27;;;;;;;;;;;;46999:41;47019:4;47025:2;47029:7;47038:1;46999:19;:41::i;:::-;45785:1263;;;:::o;42392:110::-;42468:26;42478:2;42482:7;42468:26;;;;;;;;;;;;:9;:26::i;:::-;42392:110;;:::o;52752:217::-;52852:16;52860:7;52852;:16::i;:::-;52844:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;52952:9;52930:10;:19;52941:7;52930:19;;;;;;;;;;;:31;;;;;;;;;;;;:::i;:::-;;52752:217;;:::o;41491:128::-;41556:4;41609:1;41580:31;;:17;41589:7;41580:8;:17::i;:::-;:31;;;;41573:38;;41491:128;;;:::o;61966:111::-;62051:20;62063:7;62051:11;:20::i;:::-;61966:111;:::o;41061:117::-;41127:7;41154;:16;41162:7;41154:16;;;;;;;;;;;;;;;;;;;;;41147:23;;41061:117;;;:::o;47484:315::-;47639:8;47630:17;;:5;:17;;;47622:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;47726:8;47688:18;:25;47707:5;47688:25;;;;;;;;;;;;;;;:35;47714:8;47688:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;47772:8;47750:41;;47765:5;47750:41;;;47782:8;47750:41;;;;;;:::i;:::-;;;;;;;;47484:315;;;:::o;40634:313::-;40790:28;40800:4;40806:2;40810:7;40790:9;:28::i;:::-;40837:47;40860:4;40866:2;40870:7;40879:4;40837:22;:47::i;:::-;40829:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;40634:313;;;;:::o;51972:624::-;52045:13;52071:23;52086:7;52071:14;:23::i;:::-;52107;52133:10;:19;52144:7;52133:19;;;;;;;;;;;52107:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52163:18;52184:10;:8;:10::i;:::-;52163:31;;52292:1;52276:4;52270:18;:23;52266:72;;52317:9;52310:16;;;;;;52266:72;52468:1;52448:9;52442:23;:27;52438:108;;;52517:4;52523:9;52500:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52486:48;;;;;;52438:108;52565:23;52580:7;52565:14;:23::i;:::-;52558:30;;;;51972:624;;;;:::o;35629:305::-;35731:4;35783:25;35768:40;;;:11;:40;;;;:105;;;;35840:33;35825:48;;;:11;:48;;;;35768:105;:158;;;;35890:36;35914:11;35890:23;:36::i;:::-;35768:158;35748:178;;35629:305;;;:::o;61723:237::-;61898:56;61925:4;61931:2;61935:7;61944:9;61898:26;:56::i;:::-;61723:237;;;;:::o;51304:158::-;;;;;:::o;42729:319::-;42858:18;42864:2;42868:7;42858:5;:18::i;:::-;42909:53;42940:1;42944:2;42948:7;42957:4;42909:22;:53::i;:::-;42887:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;42729:319;;;:::o;53194:206::-;53263:20;53275:7;53263:11;:20::i;:::-;53337:1;53306:10;:19;53317:7;53306:19;;;;;;;;;;;53300:33;;;;;:::i;:::-;;;:38;53296:97;;53362:10;:19;53373:7;53362:19;;;;;;;;;;;;53355:26;;;;:::i;:::-;53296:97;53194:206;:::o;48587:853::-;48741:4;48762:15;:2;:13;;;:15::i;:::-;48758:675;;;48814:2;48798:36;;;48835:12;:10;:12::i;:::-;48849:4;48855:7;48864:4;48798:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;48794:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49056:1;49039:6;:13;:18;49035:328;;49082:60;;;;;;;;;;:::i;:::-;;;;;;;;49035:328;49313:6;49307:13;49298:6;49294:2;49290:15;49283:38;48794:584;48930:41;;;48920:51;;;:6;:51;;;;48913:58;;;;;48758:675;49417:4;49410:11;;48587:853;;;;;;;:::o;37431:94::-;37482:13;37508:9;;;;;;;;;;;;;;37431:94;:::o;36901:281::-;36974:13;37000:23;37015:7;37000:14;:23::i;:::-;37036:21;37060:10;:8;:10::i;:::-;37036:34;;37112:1;37094:7;37088:21;:25;:86;;;;;;;;;;;;;;;;;37140:7;37149:18;:7;:16;:18::i;:::-;37123:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;37088:86;37081:93;;;36901:281;;;:::o;28202:157::-;28287:4;28326:25;28311:40;;;:11;:40;;;;28304:47;;28202:157;;;:::o;56606:915::-;56783:61;56810:4;56816:2;56820:12;56834:9;56783:26;:61::i;:::-;56873:1;56861:9;:13;56857:222;;;57004:63;;;;;;;;;;:::i;:::-;;;;;;;;56857:222;57091:15;57109:12;57091:30;;57154:1;57138:18;;:4;:18;;;57134:187;;57173:40;57205:7;57173:31;:40::i;:::-;57134:187;;;57243:2;57235:10;;:4;:10;;;57231:90;;57262:47;57295:4;57301:7;57262:32;:47::i;:::-;57231:90;57134:187;57349:1;57335:16;;:2;:16;;;57331:183;;57368:45;57405:7;57368:36;:45::i;:::-;57331:183;;;57441:4;57435:10;;:2;:10;;;57431:83;;57462:40;57490:2;57494:7;57462:27;:40::i;:::-;57431:83;57331:183;56772:749;56606:915;;;;:::o;43384:942::-;43478:1;43464:16;;:2;:16;;;43456:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;43537:16;43545:7;43537;:16::i;:::-;43536:17;43528:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;43599:48;43628:1;43632:2;43636:7;43645:1;43599:20;:48::i;:::-;43746:16;43754:7;43746;:16::i;:::-;43745:17;43737:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;44161:1;44144:9;:13;44154:2;44144:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;44205:2;44186:7;:16;44194:7;44186:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;44250:7;44246:2;44225:33;;44242:1;44225:33;;;;;;;;;;;;44271:47;44299:1;44303:2;44307:7;44316:1;44271:19;:47::i;:::-;43384:942;;:::o;44665:783::-;44725:13;44741:23;44756:7;44741:14;:23::i;:::-;44725:39;;44777:51;44798:5;44813:1;44817:7;44826:1;44777:20;:51::i;:::-;44941:23;44956:7;44941:14;:23::i;:::-;44933:31;;45012:15;:24;45028:7;45012:24;;;;;;;;;;;;45005:31;;;;;;;;;;;45277:1;45257:9;:16;45267:5;45257:16;;;;;;;;;;;;;;;;:21;;;;;;;;;;;45307:7;:16;45315:7;45307:16;;;;;;;;;;;;45300:23;;;;;;;;;;;45369:7;45365:1;45341:36;;45350:5;45341:36;;;;;;;;;;;;45390:50;45410:5;45425:1;45429:7;45438:1;45390:19;:50::i;:::-;44714:734;44665:783;:::o;18269:326::-;18329:4;18586:1;18564:7;:19;;;:23;18557:30;;18269:326;;;:::o;14130:716::-;14186:13;14237:14;14274:1;14254:17;14265:5;14254:10;:17::i;:::-;:21;14237:38;;14290:20;14324:6;14313:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14290:41;;14346:11;14475:6;14471:2;14467:15;14459:6;14455:28;14448:35;;14512:288;14519:4;14512:288;;;14544:5;;;;;;;;14686:8;14681:2;14674:5;14670:14;14665:30;14660:3;14652:44;14742:2;14733:11;;;;;;:::i;:::-;;;;;14776:1;14767:5;:10;14512:288;14763:21;14512:288;14821:6;14814:13;;;;;14130:716;;;:::o;50172:410::-;50362:1;50350:9;:13;50346:229;;;50400:1;50384:18;;:4;:18;;;50380:87;;50442:9;50423;:15;50433:4;50423:15;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;50380:87;50499:1;50485:16;;:2;:16;;;50481:83;;50539:9;50522;:13;50532:2;50522:13;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;50481:83;50346:229;50172:410;;;;:::o;58244:164::-;58348:10;:17;;;;58321:15;:24;58337:7;58321:24;;;;;;;;;;;:44;;;;58376:10;58392:7;58376:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58244:164;:::o;59035:988::-;59301:22;59351:1;59326:22;59343:4;59326:16;:22::i;:::-;:26;;;;:::i;:::-;59301:51;;59363:18;59384:17;:26;59402:7;59384:26;;;;;;;;;;;;59363:47;;59531:14;59517:10;:28;59513:328;;59562:19;59584:12;:18;59597:4;59584:18;;;;;;;;;;;;;;;:34;59603:14;59584:34;;;;;;;;;;;;59562:56;;59668:11;59635:12;:18;59648:4;59635:18;;;;;;;;;;;;;;;:30;59654:10;59635:30;;;;;;;;;;;:44;;;;59785:10;59752:17;:30;59770:11;59752:30;;;;;;;;;;;:43;;;;59547:294;59513:328;59937:17;:26;59955:7;59937:26;;;;;;;;;;;59930:33;;;59981:12;:18;59994:4;59981:18;;;;;;;;;;;;;;;:34;60000:14;59981:34;;;;;;;;;;;59974:41;;;59116:907;;59035:988;;:::o;60318:1079::-;60571:22;60616:1;60596:10;:17;;;;:21;;;;:::i;:::-;60571:46;;60628:18;60649:15;:24;60665:7;60649:24;;;;;;;;;;;;60628:45;;61000:19;61022:10;61033:14;61022:26;;;;;;;;:::i;:::-;;;;;;;;;;61000:48;;61086:11;61061:10;61072;61061:22;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;61197:10;61166:15;:28;61182:11;61166:28;;;;;;;;;;;:41;;;;61338:15;:24;61354:7;61338:24;;;;;;;;;;;61331:31;;;61373:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;60389:1008;;;60318:1079;:::o;57822:221::-;57907:14;57924:20;57941:2;57924:16;:20::i;:::-;57907:37;;57982:7;57955:12;:16;57968:2;57955:16;;;;;;;;;;;;;;;:24;57972:6;57955:24;;;;;;;;;;;:34;;;;58029:6;58000:17;:26;58018:7;58000:26;;;;;;;;;;;:35;;;;57896:147;57822:221;;:::o;11017:922::-;11070:7;11090:14;11107:1;11090:18;;11157:6;11148:5;:15;11144:102;;11193:6;11184:15;;;;;;:::i;:::-;;;;;11228:2;11218:12;;;;11144:102;11273:6;11264:5;:15;11260:102;;11309:6;11300:15;;;;;;:::i;:::-;;;;;11344:2;11334:12;;;;11260:102;11389:6;11380:5;:15;11376:102;;11425:6;11416:15;;;;;;:::i;:::-;;;;;11460:2;11450:12;;;;11376:102;11505:5;11496;:14;11492:99;;11540:5;11531:14;;;;;;:::i;:::-;;;;;11574:1;11564:11;;;;11492:99;11618:5;11609;:14;11605:99;;11653:5;11644:14;;;;;;:::i;:::-;;;;;11687:1;11677:11;;;;11605:99;11731:5;11722;:14;11718:99;;11766:5;11757:14;;;;;;:::i;:::-;;;;;11800:1;11790:11;;;;11718:99;11844:5;11835;:14;11831:66;;11880:1;11870:11;;;;11831:66;11925:6;11918:13;;;11017:922;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::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:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:307::-;1866:1;1876:113;1890:6;1887:1;1884:13;1876:113;;;1975:1;1970:3;1966:11;1960:18;1956:1;1951:3;1947:11;1940:39;1912:2;1909:1;1905:10;1900:15;;1876:113;;;2007:6;2004:1;2001:13;1998:101;;;2087:1;2078:6;2073:3;2069:16;2062:27;1998:101;1847:258;1798:307;;;:::o;2111:102::-;2152:6;2203:2;2199:7;2194:2;2187:5;2183:14;2179:28;2169:38;;2111:102;;;:::o;2219:364::-;2307:3;2335:39;2368:5;2335:39;:::i;:::-;2390:71;2454:6;2449:3;2390:71;:::i;:::-;2383:78;;2470:52;2515:6;2510:3;2503:4;2496:5;2492:16;2470:52;:::i;:::-;2547:29;2569:6;2547:29;:::i;:::-;2542:3;2538:39;2531:46;;2311:272;2219:364;;;;:::o;2589:313::-;2702:4;2740:2;2729:9;2725:18;2717:26;;2789:9;2783:4;2779:20;2775:1;2764:9;2760:17;2753:47;2817:78;2890:4;2881:6;2817:78;:::i;:::-;2809:86;;2589:313;;;;:::o;2908:77::-;2945:7;2974:5;2963:16;;2908:77;;;:::o;2991:122::-;3064:24;3082:5;3064:24;:::i;:::-;3057:5;3054:35;3044:63;;3103:1;3100;3093:12;3044:63;2991:122;:::o;3119:139::-;3165:5;3203:6;3190:20;3181:29;;3219:33;3246:5;3219:33;:::i;:::-;3119:139;;;;:::o;3264:329::-;3323:6;3372:2;3360:9;3351:7;3347:23;3343:32;3340:119;;;3378:79;;:::i;:::-;3340:119;3498:1;3523:53;3568:7;3559:6;3548:9;3544:22;3523:53;:::i;:::-;3513:63;;3469:117;3264:329;;;;:::o;3599:126::-;3636:7;3676:42;3669:5;3665:54;3654:65;;3599:126;;;:::o;3731:96::-;3768:7;3797:24;3815:5;3797:24;:::i;:::-;3786:35;;3731:96;;;:::o;3833:118::-;3920:24;3938:5;3920:24;:::i;:::-;3915:3;3908:37;3833:118;;:::o;3957:222::-;4050:4;4088:2;4077:9;4073:18;4065:26;;4101:71;4169:1;4158:9;4154:17;4145:6;4101:71;:::i;:::-;3957:222;;;;:::o;4185:122::-;4258:24;4276:5;4258:24;:::i;:::-;4251:5;4248:35;4238:63;;4297:1;4294;4287:12;4238:63;4185:122;:::o;4313:139::-;4359:5;4397:6;4384:20;4375:29;;4413:33;4440:5;4413:33;:::i;:::-;4313:139;;;;:::o;4458:474::-;4526:6;4534;4583:2;4571:9;4562:7;4558:23;4554:32;4551:119;;;4589:79;;:::i;:::-;4551:119;4709:1;4734:53;4779:7;4770:6;4759:9;4755:22;4734:53;:::i;:::-;4724:63;;4680:117;4836:2;4862:53;4907:7;4898:6;4887:9;4883:22;4862:53;:::i;:::-;4852:63;;4807:118;4458:474;;;;;:::o;4938:118::-;5025:24;5043:5;5025:24;:::i;:::-;5020:3;5013:37;4938:118;;:::o;5062:222::-;5155:4;5193:2;5182:9;5178:18;5170:26;;5206:71;5274:1;5263:9;5259:17;5250:6;5206:71;:::i;:::-;5062:222;;;;:::o;5290:619::-;5367:6;5375;5383;5432:2;5420:9;5411:7;5407:23;5403:32;5400:119;;;5438:79;;:::i;:::-;5400:119;5558:1;5583:53;5628:7;5619:6;5608:9;5604:22;5583:53;:::i;:::-;5573:63;;5529:117;5685:2;5711:53;5756:7;5747:6;5736:9;5732:22;5711:53;:::i;:::-;5701:63;;5656:118;5813:2;5839:53;5884:7;5875:6;5864:9;5860:22;5839:53;:::i;:::-;5829:63;;5784:118;5290:619;;;;;:::o;5915:117::-;6024:1;6021;6014:12;6038:117;6147:1;6144;6137:12;6161:180;6209:77;6206:1;6199:88;6306:4;6303:1;6296:15;6330:4;6327:1;6320:15;6347:281;6430:27;6452:4;6430:27;:::i;:::-;6422:6;6418:40;6560:6;6548:10;6545:22;6524:18;6512:10;6509:34;6506:62;6503:88;;;6571:18;;:::i;:::-;6503:88;6611:10;6607:2;6600:22;6390:238;6347:281;;:::o;6634:129::-;6668:6;6695:20;;:::i;:::-;6685:30;;6724:33;6752:4;6744:6;6724:33;:::i;:::-;6634:129;;;:::o;6769:308::-;6831:4;6921:18;6913:6;6910:30;6907:56;;;6943:18;;:::i;:::-;6907:56;6981:29;7003:6;6981:29;:::i;:::-;6973:37;;7065:4;7059;7055:15;7047:23;;6769:308;;;:::o;7083:154::-;7167:6;7162:3;7157;7144:30;7229:1;7220:6;7215:3;7211:16;7204:27;7083:154;;;:::o;7243:412::-;7321:5;7346:66;7362:49;7404:6;7362:49;:::i;:::-;7346:66;:::i;:::-;7337:75;;7435:6;7428:5;7421:21;7473:4;7466:5;7462:16;7511:3;7502:6;7497:3;7493:16;7490:25;7487:112;;;7518:79;;:::i;:::-;7487:112;7608:41;7642:6;7637:3;7632;7608:41;:::i;:::-;7327:328;7243:412;;;;;:::o;7675:340::-;7731:5;7780:3;7773:4;7765:6;7761:17;7757:27;7747:122;;7788:79;;:::i;:::-;7747:122;7905:6;7892:20;7930:79;8005:3;7997:6;7990:4;7982:6;7978:17;7930:79;:::i;:::-;7921:88;;7737:278;7675:340;;;;:::o;8021:654::-;8099:6;8107;8156:2;8144:9;8135:7;8131:23;8127:32;8124:119;;;8162:79;;:::i;:::-;8124:119;8310:1;8299:9;8295:17;8282:31;8340:18;8332:6;8329:30;8326:117;;;8362:79;;:::i;:::-;8326:117;8467:63;8522:7;8513:6;8502:9;8498:22;8467:63;:::i;:::-;8457:73;;8253:287;8579:2;8605:53;8650:7;8641:6;8630:9;8626:22;8605:53;:::i;:::-;8595:63;;8550:118;8021:654;;;;;:::o;8681:329::-;8740:6;8789:2;8777:9;8768:7;8764:23;8760:32;8757:119;;;8795:79;;:::i;:::-;8757:119;8915:1;8940:53;8985:7;8976:6;8965:9;8961:22;8940:53;:::i;:::-;8930:63;;8886:117;8681:329;;;;:::o;9016:116::-;9086:21;9101:5;9086:21;:::i;:::-;9079:5;9076:32;9066:60;;9122:1;9119;9112:12;9066:60;9016:116;:::o;9138:133::-;9181:5;9219:6;9206:20;9197:29;;9235:30;9259:5;9235:30;:::i;:::-;9138:133;;;;:::o;9277:468::-;9342:6;9350;9399:2;9387:9;9378:7;9374:23;9370:32;9367:119;;;9405:79;;:::i;:::-;9367:119;9525:1;9550:53;9595:7;9586:6;9575:9;9571:22;9550:53;:::i;:::-;9540:63;;9496:117;9652:2;9678:50;9720:7;9711:6;9700:9;9696:22;9678:50;:::i;:::-;9668:60;;9623:115;9277:468;;;;;:::o;9751:307::-;9812:4;9902:18;9894:6;9891:30;9888:56;;;9924:18;;:::i;:::-;9888:56;9962:29;9984:6;9962:29;:::i;:::-;9954:37;;10046:4;10040;10036:15;10028:23;;9751:307;;;:::o;10064:410::-;10141:5;10166:65;10182:48;10223:6;10182:48;:::i;:::-;10166:65;:::i;:::-;10157:74;;10254:6;10247:5;10240:21;10292:4;10285:5;10281:16;10330:3;10321:6;10316:3;10312:16;10309:25;10306:112;;;10337:79;;:::i;:::-;10306:112;10427:41;10461:6;10456:3;10451;10427:41;:::i;:::-;10147:327;10064:410;;;;;:::o;10493:338::-;10548:5;10597:3;10590:4;10582:6;10578:17;10574:27;10564:122;;10605:79;;:::i;:::-;10564:122;10722:6;10709:20;10747:78;10821:3;10813:6;10806:4;10798:6;10794:17;10747:78;:::i;:::-;10738:87;;10554:277;10493:338;;;;:::o;10837:943::-;10932:6;10940;10948;10956;11005:3;10993:9;10984:7;10980:23;10976:33;10973:120;;;11012:79;;:::i;:::-;10973:120;11132:1;11157:53;11202:7;11193:6;11182:9;11178:22;11157:53;:::i;:::-;11147:63;;11103:117;11259:2;11285:53;11330:7;11321:6;11310:9;11306:22;11285:53;:::i;:::-;11275:63;;11230:118;11387:2;11413:53;11458:7;11449:6;11438:9;11434:22;11413:53;:::i;:::-;11403:63;;11358:118;11543:2;11532:9;11528:18;11515:32;11574:18;11566:6;11563:30;11560:117;;;11596:79;;:::i;:::-;11560:117;11701:62;11755:7;11746:6;11735:9;11731:22;11701:62;:::i;:::-;11691:72;;11486:287;10837:943;;;;;;;:::o;11786:509::-;11855:6;11904:2;11892:9;11883:7;11879:23;11875:32;11872:119;;;11910:79;;:::i;:::-;11872:119;12058:1;12047:9;12043:17;12030:31;12088:18;12080:6;12077:30;12074:117;;;12110:79;;:::i;:::-;12074:117;12215:63;12270:7;12261:6;12250:9;12246:22;12215:63;:::i;:::-;12205:73;;12001:287;11786:509;;;;:::o;12301:474::-;12369:6;12377;12426:2;12414:9;12405:7;12401:23;12397:32;12394:119;;;12432:79;;:::i;:::-;12394:119;12552:1;12577:53;12622:7;12613:6;12602:9;12598:22;12577:53;:::i;:::-;12567:63;;12523:117;12679:2;12705:53;12750:7;12741:6;12730:9;12726:22;12705:53;:::i;:::-;12695:63;;12650:118;12301:474;;;;;:::o;12781:180::-;12829:77;12826:1;12819:88;12926:4;12923:1;12916:15;12950:4;12947:1;12940:15;12967:320;13011:6;13048:1;13042:4;13038:12;13028:22;;13095:1;13089:4;13085:12;13116:18;13106:81;;13172:4;13164:6;13160:17;13150:27;;13106:81;13234:2;13226:6;13223:14;13203:18;13200:38;13197:84;;13253:18;;:::i;:::-;13197:84;13018:269;12967:320;;;:::o;13293:220::-;13433:34;13429:1;13421:6;13417:14;13410:58;13502:3;13497:2;13489:6;13485:15;13478:28;13293:220;:::o;13519:366::-;13661:3;13682:67;13746:2;13741:3;13682:67;:::i;:::-;13675:74;;13758:93;13847:3;13758:93;:::i;:::-;13876:2;13871:3;13867:12;13860:19;;13519:366;;;:::o;13891:419::-;14057:4;14095:2;14084:9;14080:18;14072:26;;14144:9;14138:4;14134:20;14130:1;14119:9;14115:17;14108:47;14172:131;14298:4;14172:131;:::i;:::-;14164:139;;13891:419;;;:::o;14316:248::-;14456:34;14452:1;14444:6;14440:14;14433:58;14525:31;14520:2;14512:6;14508:15;14501:56;14316:248;:::o;14570:366::-;14712:3;14733:67;14797:2;14792:3;14733:67;:::i;:::-;14726:74;;14809:93;14898:3;14809:93;:::i;:::-;14927:2;14922:3;14918:12;14911:19;;14570:366;;;:::o;14942:419::-;15108:4;15146:2;15135:9;15131:18;15123:26;;15195:9;15189:4;15185:20;15181:1;15170:9;15166:17;15159:47;15223:131;15349:4;15223:131;:::i;:::-;15215:139;;14942:419;;;:::o;15367:232::-;15507:34;15503:1;15495:6;15491:14;15484:58;15576:15;15571:2;15563:6;15559:15;15552:40;15367:232;:::o;15605:366::-;15747:3;15768:67;15832:2;15827:3;15768:67;:::i;:::-;15761:74;;15844:93;15933:3;15844:93;:::i;:::-;15962:2;15957:3;15953:12;15946:19;;15605:366;;;:::o;15977:419::-;16143:4;16181:2;16170:9;16166:18;16158:26;;16230:9;16224:4;16220:20;16216:1;16205:9;16201:17;16194:47;16258:131;16384:4;16258:131;:::i;:::-;16250:139;;15977:419;;;:::o;16402:180::-;16450:77;16447:1;16440:88;16547:4;16544:1;16537:15;16571:4;16568:1;16561:15;16588:233;16627:3;16650:24;16668:5;16650:24;:::i;:::-;16641:33;;16696:66;16689:5;16686:77;16683:103;;16766:18;;:::i;:::-;16683:103;16813:1;16806:5;16802:13;16795:20;;16588:233;;;:::o;16827:230::-;16967:34;16963:1;16955:6;16951:14;16944:58;17036:13;17031:2;17023:6;17019:15;17012:38;16827:230;:::o;17063:366::-;17205:3;17226:67;17290:2;17285:3;17226:67;:::i;:::-;17219:74;;17302:93;17391:3;17302:93;:::i;:::-;17420:2;17415:3;17411:12;17404:19;;17063:366;;;:::o;17435:419::-;17601:4;17639:2;17628:9;17624:18;17616:26;;17688:9;17682:4;17678:20;17674:1;17663:9;17659:17;17652:47;17716:131;17842:4;17716:131;:::i;:::-;17708:139;;17435:419;;;:::o;17860:174::-;18000:26;17996:1;17988:6;17984:14;17977:50;17860:174;:::o;18040:366::-;18182:3;18203:67;18267:2;18262:3;18203:67;:::i;:::-;18196:74;;18279:93;18368:3;18279:93;:::i;:::-;18397:2;18392:3;18388:12;18381:19;;18040:366;;;:::o;18412:419::-;18578:4;18616:2;18605:9;18601:18;18593:26;;18665:9;18659:4;18655:20;18651:1;18640:9;18636:17;18629:47;18693:131;18819:4;18693:131;:::i;:::-;18685:139;;18412:419;;;:::o;18837:231::-;18977:34;18973:1;18965:6;18961:14;18954:58;19046:14;19041:2;19033:6;19029:15;19022:39;18837:231;:::o;19074:366::-;19216:3;19237:67;19301:2;19296:3;19237:67;:::i;:::-;19230:74;;19313:93;19402:3;19313:93;:::i;:::-;19431:2;19426:3;19422:12;19415:19;;19074:366;;;:::o;19446:419::-;19612:4;19650:2;19639:9;19635:18;19627:26;;19699:9;19693:4;19689:20;19685:1;19674:9;19670:17;19663:47;19727:131;19853:4;19727:131;:::i;:::-;19719:139;;19446:419;;;:::o;19871:180::-;19919:77;19916:1;19909:88;20016:4;20013:1;20006:15;20040:4;20037:1;20030:15;20057:159;20197:11;20193:1;20185:6;20181:14;20174:35;20057:159;:::o;20222:365::-;20364:3;20385:66;20449:1;20444:3;20385:66;:::i;:::-;20378:73;;20460:93;20549:3;20460:93;:::i;:::-;20578:2;20573:3;20569:12;20562:19;;20222:365;;;:::o;20593:419::-;20759:4;20797:2;20786:9;20782:18;20774:26;;20846:9;20840:4;20836:20;20832:1;20821:9;20817:17;20810:47;20874:131;21000:4;20874:131;:::i;:::-;20866:139;;20593:419;;;:::o;21018:174::-;21158:26;21154:1;21146:6;21142:14;21135:50;21018:174;:::o;21198:366::-;21340:3;21361:67;21425:2;21420:3;21361:67;:::i;:::-;21354:74;;21437:93;21526:3;21437:93;:::i;:::-;21555:2;21550:3;21546:12;21539:19;;21198:366;;;:::o;21570:419::-;21736:4;21774:2;21763:9;21759:18;21751:26;;21823:9;21817:4;21813:20;21809:1;21798:9;21794:17;21787:47;21851:131;21977:4;21851:131;:::i;:::-;21843:139;;21570:419;;;:::o;21995:228::-;22135:34;22131:1;22123:6;22119:14;22112:58;22204:11;22199:2;22191:6;22187:15;22180:36;21995:228;:::o;22229:366::-;22371:3;22392:67;22456:2;22451:3;22392:67;:::i;:::-;22385:74;;22468:93;22557:3;22468:93;:::i;:::-;22586:2;22581:3;22577:12;22570:19;;22229:366;;;:::o;22601:419::-;22767:4;22805:2;22794:9;22790:18;22782:26;;22854:9;22848:4;22844:20;22840:1;22829:9;22825:17;22818:47;22882:131;23008:4;22882:131;:::i;:::-;22874:139;;22601:419;;;:::o;23026:224::-;23166:34;23162:1;23154:6;23150:14;23143:58;23235:7;23230:2;23222:6;23218:15;23211:32;23026:224;:::o;23256:366::-;23398:3;23419:67;23483:2;23478:3;23419:67;:::i;:::-;23412:74;;23495:93;23584:3;23495:93;:::i;:::-;23613:2;23608:3;23604:12;23597:19;;23256:366;;;:::o;23628:419::-;23794:4;23832:2;23821:9;23817:18;23809:26;;23881:9;23875:4;23871:20;23867:1;23856:9;23852:17;23845:47;23909:131;24035:4;23909:131;:::i;:::-;23901:139;;23628:419;;;:::o;24053:223::-;24193:34;24189:1;24181:6;24177:14;24170:58;24262:6;24257:2;24249:6;24245:15;24238:31;24053:223;:::o;24282:366::-;24424:3;24445:67;24509:2;24504:3;24445:67;:::i;:::-;24438:74;;24521:93;24610:3;24521:93;:::i;:::-;24639:2;24634:3;24630:12;24623:19;;24282:366;;;:::o;24654:419::-;24820:4;24858:2;24847:9;24843:18;24835:26;;24907:9;24901:4;24897:20;24893:1;24882:9;24878:17;24871:47;24935:131;25061:4;24935:131;:::i;:::-;24927:139;;24654:419;;;:::o;25079:233::-;25219:34;25215:1;25207:6;25203:14;25196:58;25288:16;25283:2;25275:6;25271:15;25264:41;25079:233;:::o;25318:366::-;25460:3;25481:67;25545:2;25540:3;25481:67;:::i;:::-;25474:74;;25557:93;25646:3;25557:93;:::i;:::-;25675:2;25670:3;25666:12;25659:19;;25318:366;;;:::o;25690:419::-;25856:4;25894:2;25883:9;25879:18;25871:26;;25943:9;25937:4;25933:20;25929:1;25918:9;25914:17;25907:47;25971:131;26097:4;25971:131;:::i;:::-;25963:139;;25690:419;;;:::o;26115:175::-;26255:27;26251:1;26243:6;26239:14;26232:51;26115:175;:::o;26296:366::-;26438:3;26459:67;26523:2;26518:3;26459:67;:::i;:::-;26452:74;;26535:93;26624:3;26535:93;:::i;:::-;26653:2;26648:3;26644:12;26637:19;;26296:366;;;:::o;26668:419::-;26834:4;26872:2;26861:9;26857:18;26849:26;;26921:9;26915:4;26911:20;26907:1;26896:9;26892:17;26885:47;26949:131;27075:4;26949:131;:::i;:::-;26941:139;;26668:419;;;:::o;27093:237::-;27233:34;27229:1;27221:6;27217:14;27210:58;27302:20;27297:2;27289:6;27285:15;27278:45;27093:237;:::o;27336:366::-;27478:3;27499:67;27563:2;27558:3;27499:67;:::i;:::-;27492:74;;27575:93;27664:3;27575:93;:::i;:::-;27693:2;27688:3;27684:12;27677:19;;27336:366;;;:::o;27708:419::-;27874:4;27912:2;27901:9;27897:18;27889:26;;27961:9;27955:4;27951:20;27947:1;27936:9;27932:17;27925:47;27989:131;28115:4;27989:131;:::i;:::-;27981:139;;27708:419;;;:::o;28133:148::-;28235:11;28272:3;28257:18;;28133:148;;;;:::o;28287:377::-;28393:3;28421:39;28454:5;28421:39;:::i;:::-;28476:89;28558:6;28553:3;28476:89;:::i;:::-;28469:96;;28574:52;28619:6;28614:3;28607:4;28600:5;28596:16;28574:52;:::i;:::-;28651:6;28646:3;28642:16;28635:23;;28397:267;28287:377;;;;:::o;28670:435::-;28850:3;28872:95;28963:3;28954:6;28872:95;:::i;:::-;28865:102;;28984:95;29075:3;29066:6;28984:95;:::i;:::-;28977:102;;29096:3;29089:10;;28670:435;;;;;:::o;29111:98::-;29162:6;29196:5;29190:12;29180:22;;29111:98;;;:::o;29215:168::-;29298:11;29332:6;29327:3;29320:19;29372:4;29367:3;29363:14;29348:29;;29215:168;;;;:::o;29389:360::-;29475:3;29503:38;29535:5;29503:38;:::i;:::-;29557:70;29620:6;29615:3;29557:70;:::i;:::-;29550:77;;29636:52;29681:6;29676:3;29669:4;29662:5;29658:16;29636:52;:::i;:::-;29713:29;29735:6;29713:29;:::i;:::-;29708:3;29704:39;29697:46;;29479:270;29389:360;;;;:::o;29755:640::-;29950:4;29988:3;29977:9;29973:19;29965:27;;30002:71;30070:1;30059:9;30055:17;30046:6;30002:71;:::i;:::-;30083:72;30151:2;30140:9;30136:18;30127:6;30083:72;:::i;:::-;30165;30233:2;30222:9;30218:18;30209:6;30165:72;:::i;:::-;30284:9;30278:4;30274:20;30269:2;30258:9;30254:18;30247:48;30312:76;30383:4;30374:6;30312:76;:::i;:::-;30304:84;;29755:640;;;;;;;:::o;30401:141::-;30457:5;30488:6;30482:13;30473:22;;30504:32;30530:5;30504:32;:::i;:::-;30401:141;;;;:::o;30548:349::-;30617:6;30666:2;30654:9;30645:7;30641:23;30637:32;30634:119;;;30672:79;;:::i;:::-;30634:119;30792:1;30817:63;30872:7;30863:6;30852:9;30848:22;30817:63;:::i;:::-;30807:73;;30763:127;30548:349;;;;:::o;30903:240::-;31043:34;31039:1;31031:6;31027:14;31020:58;31112:23;31107:2;31099:6;31095:15;31088:48;30903:240;:::o;31149:366::-;31291:3;31312:67;31376:2;31371:3;31312:67;:::i;:::-;31305:74;;31388:93;31477:3;31388:93;:::i;:::-;31506:2;31501:3;31497:12;31490:19;;31149:366;;;:::o;31521:419::-;31687:4;31725:2;31714:9;31710:18;31702:26;;31774:9;31768:4;31764:20;31760:1;31749:9;31745:17;31738:47;31802:131;31928:4;31802:131;:::i;:::-;31794:139;;31521:419;;;:::o;31946:182::-;32086:34;32082:1;32074:6;32070:14;32063:58;31946:182;:::o;32134:366::-;32276:3;32297:67;32361:2;32356:3;32297:67;:::i;:::-;32290:74;;32373:93;32462:3;32373:93;:::i;:::-;32491:2;32486:3;32482:12;32475:19;;32134:366;;;:::o;32506:419::-;32672:4;32710:2;32699:9;32695:18;32687:26;;32759:9;32753:4;32749:20;32745:1;32734:9;32730:17;32723:47;32787:131;32913:4;32787:131;:::i;:::-;32779:139;;32506:419;;;:::o;32931:178::-;33071:30;33067:1;33059:6;33055:14;33048:54;32931:178;:::o;33115:366::-;33257:3;33278:67;33342:2;33337:3;33278:67;:::i;:::-;33271:74;;33354:93;33443:3;33354:93;:::i;:::-;33472:2;33467:3;33463:12;33456:19;;33115:366;;;:::o;33487:419::-;33653:4;33691:2;33680:9;33676:18;33668:26;;33740:9;33734:4;33730:20;33726:1;33715:9;33711:17;33704:47;33768:131;33894:4;33768:131;:::i;:::-;33760:139;;33487:419;;;:::o;33912:180::-;33960:77;33957:1;33950:88;34057:4;34054:1;34047:15;34081:4;34078:1;34071:15;34098:191;34138:4;34158:20;34176:1;34158:20;:::i;:::-;34153:25;;34192:20;34210:1;34192:20;:::i;:::-;34187:25;;34231:1;34228;34225:8;34222:34;;;34236:18;;:::i;:::-;34222:34;34281:1;34278;34274:9;34266:17;;34098:191;;;;:::o;34295:305::-;34335:3;34354:20;34372:1;34354:20;:::i;:::-;34349:25;;34388:20;34406:1;34388:20;:::i;:::-;34383:25;;34542:1;34474:66;34470:74;34467:1;34464:81;34461:107;;;34548:18;;:::i;:::-;34461:107;34592:1;34589;34585:9;34578:16;;34295:305;;;;:::o;34606:180::-;34654:77;34651:1;34644:88;34751:4;34748:1;34741:15;34775:4;34772:1;34765:15

Swarm Source

ipfs://a4fa150e10a95bf9ab0ef56046abd8c945f7eec6cb2179df821b1de36012a75f
Loading