Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/Counters.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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


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

pragma solidity ^0.8.0;








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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

        _owners[tokenId] = to;

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

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

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

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

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

        // Clear approvals
        delete _tokenApprovals[tokenId];

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId, 1);

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

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

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

        emit Transfer(from, to, tokenId);

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721URIStorage.sol)

pragma solidity ^0.8.0;


/**
 * @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: CrazyOwl.sol


pragma solidity ^0.8.9;





contract CrazyOwl is ERC721, ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;

    constructor() ERC721("CrazyOwl", "COWL") {}

    function safeMint(address to, string memory uri) public onlyOwner {
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }

    // The following functions are overrides required by Solidity.

    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);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":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":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"string","name":"uri","type":"string"}],"name":"safeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b506004361061010b5760003560e01c8063715018a6116100a2578063b88d4fde11610071578063b88d4fde146102a4578063c87b56dd146102c0578063d204c45e146102f0578063e985e9c51461030c578063f2fde38b1461033c5761010b565b8063715018a6146102425780638da5cb5b1461024c57806395d89b411461026a578063a22cb465146102885761010b565b806323b872dd116100de57806323b872dd146101aa57806342842e0e146101c65780636352211e146101e257806370a08231146102125761010b565b806301ffc9a71461011057806306fdde0314610140578063081812fc1461015e578063095ea7b31461018e575b600080fd5b61012a60048036038101906101259190611e05565b610358565b6040516101379190611e4d565b60405180910390f35b61014861043a565b6040516101559190611f01565b60405180910390f35b61017860048036038101906101739190611f59565b6104cc565b6040516101859190611fc7565b60405180910390f35b6101a860048036038101906101a3919061200e565b610512565b005b6101c460048036038101906101bf919061204e565b61062a565b005b6101e060048036038101906101db919061204e565b61068a565b005b6101fc60048036038101906101f79190611f59565b6106aa565b6040516102099190611fc7565b60405180910390f35b61022c600480360381019061022791906120a1565b610731565b60405161023991906120dd565b60405180910390f35b61024a6107e9565b005b6102546107fd565b6040516102619190611fc7565b60405180910390f35b610272610827565b60405161027f9190611f01565b60405180910390f35b6102a2600480360381019061029d9190612124565b6108b9565b005b6102be60048036038101906102b99190612299565b6108cf565b005b6102da60048036038101906102d59190611f59565b610931565b6040516102e79190611f01565b60405180910390f35b61030a600480360381019061030591906123bd565b610943565b005b61032660048036038101906103219190612419565b61097c565b6040516103339190611e4d565b60405180910390f35b610356600480360381019061035191906120a1565b610a10565b005b60007f80ac58cd000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916148061042357507f5b5e139f000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916145b80610433575061043282610a94565b5b9050919050565b60606000805461044990612488565b80601f016020809104026020016040519081016040528092919081815260200182805461047590612488565b80156104c25780601f10610497576101008083540402835291602001916104c2565b820191906000526020600020905b8154815290600101906020018083116104a557829003601f168201915b5050505050905090565b60006104d782610afe565b6004600083815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b600061051d826106aa565b90508073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141561058e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105859061252c565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff166105ad610b49565b73ffffffffffffffffffffffffffffffffffffffff1614806105dc57506105db816105d6610b49565b61097c565b5b61061b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610612906125be565b60405180910390fd5b6106258383610b51565b505050565b61063b610635610b49565b82610c0a565b61067a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161067190612650565b60405180910390fd5b610685838383610c9f565b505050565b6106a5838383604051806020016040528060008152506108cf565b505050565b6000806106b683610f99565b9050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610728576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161071f906126bc565b60405180910390fd5b80915050919050565b60008073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156107a2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107999061274e565b60405180910390fd5b600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b6107f1610fd6565b6107fb6000611054565b565b6000600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b60606001805461083690612488565b80601f016020809104026020016040519081016040528092919081815260200182805461086290612488565b80156108af5780601f10610884576101008083540402835291602001916108af565b820191906000526020600020905b81548152906001019060200180831161089257829003601f168201915b5050505050905090565b6108cb6108c4610b49565b838361111a565b5050565b6108e06108da610b49565b83610c0a565b61091f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161091690612650565b60405180910390fd5b61092b84848484611287565b50505050565b606061093c826112e3565b9050919050565b61094b610fd6565b600061095760086113f6565b90506109636008611404565b61096d838261141a565b6109778183611438565b505050565b6000600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16905092915050565b610a18610fd6565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610a88576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a7f906127e0565b60405180910390fd5b610a9181611054565b50565b60007f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149050919050565b610b07816114ac565b610b46576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b3d906126bc565b60405180910390fd5b50565b600033905090565b816004600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff16610bc4836106aa565b73ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b600080610c16836106aa565b90508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161480610c585750610c57818561097c565b5b80610c9657508373ffffffffffffffffffffffffffffffffffffffff16610c7e846104cc565b73ffffffffffffffffffffffffffffffffffffffff16145b91505092915050565b8273ffffffffffffffffffffffffffffffffffffffff16610cbf826106aa565b73ffffffffffffffffffffffffffffffffffffffff1614610d15576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d0c90612872565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610d85576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d7c90612904565b60405180910390fd5b610d9283838360016114ed565b8273ffffffffffffffffffffffffffffffffffffffff16610db2826106aa565b73ffffffffffffffffffffffffffffffffffffffff1614610e08576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dff90612872565b60405180910390fd5b6004600082815260200190815260200160002060006101000a81549073ffffffffffffffffffffffffffffffffffffffff02191690556001600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825403925050819055506001600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282540192505081905550816002600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4610f948383836001611613565b505050565b60006002600083815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b610fde610b49565b73ffffffffffffffffffffffffffffffffffffffff16610ffc6107fd565b73ffffffffffffffffffffffffffffffffffffffff1614611052576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161104990612970565b60405180910390fd5b565b6000600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600760006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611189576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611180906129dc565b60405180910390fd5b80600560008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c318360405161127a9190611e4d565b60405180910390a3505050565b611292848484610c9f565b61129e84848484611619565b6112dd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112d490612a6e565b60405180910390fd5b50505050565b60606112ee82610afe565b600060066000848152602001908152602001600020805461130e90612488565b80601f016020809104026020016040519081016040528092919081815260200182805461133a90612488565b80156113875780601f1061135c57610100808354040283529160200191611387565b820191906000526020600020905b81548152906001019060200180831161136a57829003601f168201915b5050505050905060006113986117b0565b90506000815114156113ae5781925050506113f1565b6000825111156113e35780826040516020016113cb929190612aca565b604051602081830303815290604052925050506113f1565b6113ec846117c7565b925050505b919050565b600081600001549050919050565b6001816000016000828254019250508190555050565b61143482826040518060200160405280600081525061182f565b5050565b611441826114ac565b611480576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161147790612b60565b60405180910390fd5b806006600084815260200190815260200160002090805190602001906114a7929190611cf6565b505050565b60008073ffffffffffffffffffffffffffffffffffffffff166114ce83610f99565b73ffffffffffffffffffffffffffffffffffffffff1614159050919050565b600181111561160d57600073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16146115815780600360008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546115799190612baf565b925050819055505b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161461160c5780600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546116049190612be3565b925050819055505b5b50505050565b50505050565b600061163a8473ffffffffffffffffffffffffffffffffffffffff1661188a565b156117a3578373ffffffffffffffffffffffffffffffffffffffff1663150b7a02611663610b49565b8786866040518563ffffffff1660e01b81526004016116859493929190612c8e565b602060405180830381600087803b15801561169f57600080fd5b505af19250505080156116d057506040513d601f19601f820116820180604052508101906116cd9190612cef565b60015b611753573d8060008114611700576040519150601f19603f3d011682016040523d82523d6000602084013e611705565b606091505b5060008151141561174b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161174290612a6e565b60405180910390fd5b805181602001fd5b63150b7a0260e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149150506117a8565b600190505b949350505050565b606060405180602001604052806000815250905090565b60606117d282610afe565b60006117dc6117b0565b905060008151116117fc5760405180602001604052806000815250611827565b80611806846118ad565b604051602001611817929190612aca565b6040516020818303038152906040525b915050919050565b6118398383611985565b6118466000848484611619565b611885576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161187c90612a6e565b60405180910390fd5b505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6060600060016118bc84611ba3565b01905060008167ffffffffffffffff8111156118db576118da61216e565b5b6040519080825280601f01601f19166020018201604052801561190d5781602001600182028036833780820191505090505b509050600082602001820190505b60011561197a578080600190039150507f3031323334353637383961626364656600000000000000000000000000000000600a86061a8153600a858161196457611963612d1c565b5b04945060008514156119755761197a565b61191b565b819350505050919050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156119f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119ec90612d97565b60405180910390fd5b6119fe816114ac565b15611a3e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a3590612e03565b60405180910390fd5b611a4c6000838360016114ed565b611a55816114ac565b15611a95576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a8c90612e03565b60405180910390fd5b6001600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282540192505081905550816002600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4611b9f600083836001611613565b5050565b600080600090507a184f03e93ff9f4daa797ed6e38ed64bf6a1f0100000000000000008310611c01577a184f03e93ff9f4daa797ed6e38ed64bf6a1f0100000000000000008381611bf757611bf6612d1c565b5b0492506040810190505b6d04ee2d6d415b85acef81000000008310611c3e576d04ee2d6d415b85acef81000000008381611c3457611c33612d1c565b5b0492506020810190505b662386f26fc100008310611c6d57662386f26fc100008381611c6357611c62612d1c565b5b0492506010810190505b6305f5e1008310611c96576305f5e1008381611c8c57611c8b612d1c565b5b0492506008810190505b6127108310611cbb576127108381611cb157611cb0612d1c565b5b0492506004810190505b60648310611cde5760648381611cd457611cd3612d1c565b5b0492506002810190505b600a8310611ced576001810190505b80915050919050565b828054611d0290612488565b90600052602060002090601f016020900481019282611d245760008555611d6b565b82601f10611d3d57805160ff1916838001178555611d6b565b82800160010185558215611d6b579182015b82811115611d6a578251825591602001919060010190611d4f565b5b509050611d789190611d7c565b5090565b5b80821115611d95576000816000905550600101611d7d565b5090565b6000604051905090565b600080fd5b600080fd5b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b611de281611dad565b8114611ded57600080fd5b50565b600081359050611dff81611dd9565b92915050565b600060208284031215611e1b57611e1a611da3565b5b6000611e2984828501611df0565b91505092915050565b60008115159050919050565b611e4781611e32565b82525050565b6000602082019050611e626000830184611e3e565b92915050565b600081519050919050565b600082825260208201905092915050565b60005b83811015611ea2578082015181840152602081019050611e87565b83811115611eb1576000848401525b50505050565b6000601f19601f8301169050919050565b6000611ed382611e68565b611edd8185611e73565b9350611eed818560208601611e84565b611ef681611eb7565b840191505092915050565b60006020820190508181036000830152611f1b8184611ec8565b905092915050565b6000819050919050565b611f3681611f23565b8114611f4157600080fd5b50565b600081359050611f5381611f2d565b92915050565b600060208284031215611f6f57611f6e611da3565b5b6000611f7d84828501611f44565b91505092915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000611fb182611f86565b9050919050565b611fc181611fa6565b82525050565b6000602082019050611fdc6000830184611fb8565b92915050565b611feb81611fa6565b8114611ff657600080fd5b50565b60008135905061200881611fe2565b92915050565b6000806040838503121561202557612024611da3565b5b600061203385828601611ff9565b925050602061204485828601611f44565b9150509250929050565b60008060006060848603121561206757612066611da3565b5b600061207586828701611ff9565b935050602061208686828701611ff9565b925050604061209786828701611f44565b9150509250925092565b6000602082840312156120b7576120b6611da3565b5b60006120c584828501611ff9565b91505092915050565b6120d781611f23565b82525050565b60006020820190506120f260008301846120ce565b92915050565b61210181611e32565b811461210c57600080fd5b50565b60008135905061211e816120f8565b92915050565b6000806040838503121561213b5761213a611da3565b5b600061214985828601611ff9565b925050602061215a8582860161210f565b9150509250929050565b600080fd5b600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6121a682611eb7565b810181811067ffffffffffffffff821117156121c5576121c461216e565b5b80604052505050565b60006121d8611d99565b90506121e4828261219d565b919050565b600067ffffffffffffffff8211156122045761220361216e565b5b61220d82611eb7565b9050602081019050919050565b82818337600083830152505050565b600061223c612237846121e9565b6121ce565b90508281526020810184848401111561225857612257612169565b5b61226384828561221a565b509392505050565b600082601f8301126122805761227f612164565b5b8135612290848260208601612229565b91505092915050565b600080600080608085870312156122b3576122b2611da3565b5b60006122c187828801611ff9565b94505060206122d287828801611ff9565b93505060406122e387828801611f44565b925050606085013567ffffffffffffffff81111561230457612303611da8565b5b6123108782880161226b565b91505092959194509250565b600067ffffffffffffffff8211156123375761233661216e565b5b61234082611eb7565b9050602081019050919050565b600061236061235b8461231c565b6121ce565b90508281526020810184848401111561237c5761237b612169565b5b61238784828561221a565b509392505050565b600082601f8301126123a4576123a3612164565b5b81356123b484826020860161234d565b91505092915050565b600080604083850312156123d4576123d3611da3565b5b60006123e285828601611ff9565b925050602083013567ffffffffffffffff81111561240357612402611da8565b5b61240f8582860161238f565b9150509250929050565b600080604083850312156124305761242f611da3565b5b600061243e85828601611ff9565b925050602061244f85828601611ff9565b9150509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b600060028204905060018216806124a057607f821691505b602082108114156124b4576124b3612459565b5b50919050565b7f4552433732313a20617070726f76616c20746f2063757272656e74206f776e6560008201527f7200000000000000000000000000000000000000000000000000000000000000602082015250565b6000612516602183611e73565b9150612521826124ba565b604082019050919050565b6000602082019050818103600083015261254581612509565b9050919050565b7f4552433732313a20617070726f76652063616c6c6572206973206e6f7420746f60008201527f6b656e206f776e6572206f7220617070726f76656420666f7220616c6c000000602082015250565b60006125a8603d83611e73565b91506125b38261254c565b604082019050919050565b600060208201905081810360008301526125d78161259b565b9050919050565b7f4552433732313a2063616c6c6572206973206e6f7420746f6b656e206f776e6560008201527f72206f7220617070726f76656400000000000000000000000000000000000000602082015250565b600061263a602d83611e73565b9150612645826125de565b604082019050919050565b600060208201905081810360008301526126698161262d565b9050919050565b7f4552433732313a20696e76616c696420746f6b656e2049440000000000000000600082015250565b60006126a6601883611e73565b91506126b182612670565b602082019050919050565b600060208201905081810360008301526126d581612699565b9050919050565b7f4552433732313a2061646472657373207a65726f206973206e6f74206120766160008201527f6c6964206f776e65720000000000000000000000000000000000000000000000602082015250565b6000612738602983611e73565b9150612743826126dc565b604082019050919050565b600060208201905081810360008301526127678161272b565b9050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b60006127ca602683611e73565b91506127d58261276e565b604082019050919050565b600060208201905081810360008301526127f9816127bd565b9050919050565b7f4552433732313a207472616e736665722066726f6d20696e636f72726563742060008201527f6f776e6572000000000000000000000000000000000000000000000000000000602082015250565b600061285c602583611e73565b915061286782612800565b604082019050919050565b6000602082019050818103600083015261288b8161284f565b9050919050565b7f4552433732313a207472616e7366657220746f20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b60006128ee602483611e73565b91506128f982612892565b604082019050919050565b6000602082019050818103600083015261291d816128e1565b9050919050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b600061295a602083611e73565b915061296582612924565b602082019050919050565b600060208201905081810360008301526129898161294d565b9050919050565b7f4552433732313a20617070726f766520746f2063616c6c657200000000000000600082015250565b60006129c6601983611e73565b91506129d182612990565b602082019050919050565b600060208201905081810360008301526129f5816129b9565b9050919050565b7f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560008201527f63656976657220696d706c656d656e7465720000000000000000000000000000602082015250565b6000612a58603283611e73565b9150612a63826129fc565b604082019050919050565b60006020820190508181036000830152612a8781612a4b565b9050919050565b600081905092915050565b6000612aa482611e68565b612aae8185612a8e565b9350612abe818560208601611e84565b80840191505092915050565b6000612ad68285612a99565b9150612ae28284612a99565b91508190509392505050565b7f45524337323155524953746f726167653a2055524920736574206f66206e6f6e60008201527f6578697374656e7420746f6b656e000000000000000000000000000000000000602082015250565b6000612b4a602e83611e73565b9150612b5582612aee565b604082019050919050565b60006020820190508181036000830152612b7981612b3d565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000612bba82611f23565b9150612bc583611f23565b925082821015612bd857612bd7612b80565b5b828203905092915050565b6000612bee82611f23565b9150612bf983611f23565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115612c2e57612c2d612b80565b5b828201905092915050565b600081519050919050565b600082825260208201905092915050565b6000612c6082612c39565b612c6a8185612c44565b9350612c7a818560208601611e84565b612c8381611eb7565b840191505092915050565b6000608082019050612ca36000830187611fb8565b612cb06020830186611fb8565b612cbd60408301856120ce565b8181036060830152612ccf8184612c55565b905095945050505050565b600081519050612ce981611dd9565b92915050565b600060208284031215612d0557612d04611da3565b5b6000612d1384828501612cda565b91505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4552433732313a206d696e7420746f20746865207a65726f2061646472657373600082015250565b6000612d81602083611e73565b9150612d8c82612d4b565b602082019050919050565b60006020820190508181036000830152612db081612d74565b9050919050565b7f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000600082015250565b6000612ded601c83611e73565b9150612df882612db7565b602082019050919050565b60006020820190508181036000830152612e1c81612de0565b905091905056fea26469706673582212203af6a929d3c248c75a8cb4035b3a21f6efdcff19c923309d007d0d013d36b40764736f6c63430008090033

57905:842:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40042:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40970:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42482:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42000:416;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43182:335;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43588:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40680:223;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40411:207;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19473:103;;;:::i;:::-;;18825:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41139:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42725:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43844:322;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58548:196;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58111:236;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42951:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19731:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40042:305;40144:4;40196:25;40181:40;;;:11;:40;;;;:105;;;;40253:33;40238:48;;;:11;:48;;;;40181:105;:158;;;;40303:36;40327:11;40303:23;:36::i;:::-;40181:158;40161:178;;40042:305;;;:::o;40970:100::-;41024:13;41057:5;41050:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40970:100;:::o;42482:171::-;42558:7;42578:23;42593:7;42578:14;:23::i;:::-;42621:15;:24;42637:7;42621:24;;;;;;;;;;;;;;;;;;;;;42614:31;;42482:171;;;:::o;42000:416::-;42081:13;42097:23;42112:7;42097:14;:23::i;:::-;42081:39;;42145:5;42139:11;;:2;:11;;;;42131:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;42239:5;42223:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;42248:37;42265:5;42272:12;:10;:12::i;:::-;42248:16;:37::i;:::-;42223:62;42201:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;42387:21;42396:2;42400:7;42387:8;:21::i;:::-;42070:346;42000:416;;:::o;43182:335::-;43377:41;43396:12;:10;:12::i;:::-;43410:7;43377:18;:41::i;:::-;43369:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;43481:28;43491:4;43497:2;43501:7;43481:9;:28::i;:::-;43182:335;;;:::o;43588:185::-;43726:39;43743:4;43749:2;43753:7;43726:39;;;;;;;;;;;;:16;:39::i;:::-;43588:185;;;:::o;40680:223::-;40752:7;40772:13;40788:17;40797:7;40788:8;:17::i;:::-;40772:33;;40841:1;40824:19;;:5;:19;;;;40816:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;40890:5;40883:12;;;40680:223;;;:::o;40411:207::-;40483:7;40528:1;40511:19;;:5;:19;;;;40503:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;40594:9;:16;40604:5;40594:16;;;;;;;;;;;;;;;;40587:23;;40411:207;;;:::o;19473:103::-;18711:13;:11;:13::i;:::-;19538:30:::1;19565:1;19538:18;:30::i;:::-;19473:103::o:0;18825:87::-;18871:7;18898:6;;;;;;;;;;;18891:13;;18825:87;:::o;41139:104::-;41195:13;41228:7;41221:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41139:104;:::o;42725:155::-;42820:52;42839:12;:10;:12::i;:::-;42853:8;42863;42820:18;:52::i;:::-;42725:155;;:::o;43844:322::-;44018:41;44037:12;:10;:12::i;:::-;44051:7;44018:18;:41::i;:::-;44010:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;44120:38;44134:4;44140:2;44144:7;44153:4;44120:13;:38::i;:::-;43844:322;;;;:::o;58548:196::-;58675:13;58713:23;58728:7;58713:14;:23::i;:::-;58706:30;;58548:196;;;:::o;58111:236::-;18711:13;:11;:13::i;:::-;58188:15:::1;58206:25;:15;:23;:25::i;:::-;58188:43;;58242:27;:15;:25;:27::i;:::-;58280:22;58290:2;58294:7;58280:9;:22::i;:::-;58313:26;58326:7;58335:3;58313:12;:26::i;:::-;58177:170;58111:236:::0;;:::o;42951:164::-;43048:4;43072:18;:25;43091:5;43072:25;;;;;;;;;;;;;;;:35;43098:8;43072:35;;;;;;;;;;;;;;;;;;;;;;;;;43065:42;;42951:164;;;;:::o;19731:201::-;18711:13;:11;:13::i;:::-;19840:1:::1;19820:22;;:8;:22;;;;19812:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;19896:28;19915:8;19896:18;:28::i;:::-;19731:201:::0;:::o;32554:157::-;32639:4;32678:25;32663:40;;;:11;:40;;;;32656:47;;32554:157;;;:::o;52301:135::-;52383:16;52391:7;52383;:16::i;:::-;52375:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;52301:135;:::o;17376:98::-;17429:7;17456:10;17449:17;;17376:98;:::o;51580:174::-;51682:2;51655:15;:24;51671:7;51655:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;51738:7;51734:2;51700:46;;51709:23;51724:7;51709:14;:23::i;:::-;51700:46;;;;;;;;;;;;51580:174;;:::o;46199:264::-;46292:4;46309:13;46325:23;46340:7;46325:14;:23::i;:::-;46309:39;;46378:5;46367:16;;:7;:16;;;:52;;;;46387:32;46404:5;46411:7;46387:16;:32::i;:::-;46367:52;:87;;;;46447:7;46423:31;;:20;46435:7;46423:11;:20::i;:::-;:31;;;46367:87;46359:96;;;46199:264;;;;:::o;50198:1263::-;50357:4;50330:31;;:23;50345:7;50330:14;:23::i;:::-;:31;;;50322:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;50436:1;50422:16;;:2;:16;;;;50414:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;50492:42;50513:4;50519:2;50523:7;50532:1;50492:20;:42::i;:::-;50664:4;50637:31;;:23;50652:7;50637:14;:23::i;:::-;:31;;;50629:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;50782:15;:24;50798:7;50782:24;;;;;;;;;;;;50775:31;;;;;;;;;;;51277:1;51258:9;:15;51268:4;51258:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;51310:1;51293:9;:13;51303:2;51293:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;51352:2;51333:7;:16;51341:7;51333:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;51391:7;51387:2;51372:27;;51381:4;51372:27;;;;;;;;;;;;51412:41;51432:4;51438:2;51442:7;51451:1;51412:19;:41::i;:::-;50198:1263;;;:::o;45474:117::-;45540:7;45567;:16;45575:7;45567:16;;;;;;;;;;;;;;;;;;;;;45560:23;;45474:117;;;:::o;18990:132::-;19065:12;:10;:12::i;:::-;19054:23;;:7;:5;:7::i;:::-;:23;;;19046:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;18990:132::o;20092:191::-;20166:16;20185:6;;;;;;;;;;;20166:25;;20211:8;20202:6;;:17;;;;;;;;;;;;;;;;;;20266:8;20235:40;;20256:8;20235:40;;;;;;;;;;;;20155:128;20092:191;:::o;51897:315::-;52052:8;52043:17;;:5;:17;;;;52035:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;52139:8;52101:18;:25;52120:5;52101:25;;;;;;;;;;;;;;;:35;52127:8;52101:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;52185:8;52163:41;;52178:5;52163:41;;;52195:8;52163:41;;;;;;:::i;:::-;;;;;;;;51897:315;;;:::o;45047:313::-;45203:28;45213:4;45219:2;45223:7;45203:9;:28::i;:::-;45250:47;45273:4;45279:2;45283:7;45292:4;45250:22;:47::i;:::-;45242:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;45047:313;;;;:::o;56408:624::-;56481:13;56507:23;56522:7;56507:14;:23::i;:::-;56543;56569:10;:19;56580:7;56569:19;;;;;;;;;;;56543:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56599:18;56620:10;:8;:10::i;:::-;56599:31;;56728:1;56712:4;56706:18;:23;56702:72;;;56753:9;56746:16;;;;;;56702:72;56904:1;56884:9;56878:23;:27;56874:108;;;56953:4;56959:9;56936:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;56922:48;;;;;;56874:108;57001:23;57016:7;57001:14;:23::i;:::-;56994:30;;;;56408:624;;;;:::o;905:114::-;970:7;997;:14;;;990:21;;905:114;;;:::o;1027:127::-;1134:1;1116:7;:14;;;:19;;;;;;;;;;;1027:127;:::o;46805:110::-;46881:26;46891:2;46895:7;46881:26;;;;;;;;;;;;:9;:26::i;:::-;46805:110;;:::o;57188:217::-;57288:16;57296:7;57288;:16::i;:::-;57280:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;57388:9;57366:10;:19;57377:7;57366:19;;;;;;;;;;;:31;;;;;;;;;;;;:::i;:::-;;57188:217;;:::o;45904:128::-;45969:4;46022:1;45993:31;;:17;46002:7;45993:8;:17::i;:::-;:31;;;;45986:38;;45904:128;;;:::o;54585:410::-;54775:1;54763:9;:13;54759:229;;;54813:1;54797:18;;:4;:18;;;54793:87;;54855:9;54836;:15;54846:4;54836:15;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;54793:87;54912:1;54898:16;;:2;:16;;;54894:83;;54952:9;54935;:13;54945:2;54935:13;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;54894:83;54759:229;54585:410;;;;:::o;55717:158::-;;;;;:::o;53000:853::-;53154:4;53175:15;:2;:13;;;:15::i;:::-;53171:675;;;53227:2;53211:36;;;53248:12;:10;:12::i;:::-;53262:4;53268:7;53277:4;53211:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;53207:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53469:1;53452:6;:13;:18;53448:328;;;53495:60;;;;;;;;;;:::i;:::-;;;;;;;;53448:328;53726:6;53720:13;53711:6;53707:2;53703:15;53696:38;53207:584;53343:41;;;53333:51;;;:6;:51;;;;53326:58;;;;;53171:675;53830:4;53823:11;;53000:853;;;;;;;:::o;41844:94::-;41895:13;41921:9;;;;;;;;;;;;;;41844:94;:::o;41314:281::-;41387:13;41413:23;41428:7;41413:14;:23::i;:::-;41449:21;41473:10;:8;:10::i;:::-;41449:34;;41525:1;41507:7;41501:21;:25;:86;;;;;;;;;;;;;;;;;41553:7;41562:18;:7;:16;:18::i;:::-;41536:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;41501:86;41494:93;;;41314:281;;;:::o;47142:319::-;47271:18;47277:2;47281:7;47271:5;:18::i;:::-;47322:53;47353:1;47357:2;47361:7;47370:4;47322:22;:53::i;:::-;47300:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;47142:319;;;:::o;21523:326::-;21583:4;21840:1;21818:7;:19;;;:23;21811:30;;21523:326;;;:::o;14803:716::-;14859:13;14910:14;14947:1;14927:17;14938:5;14927:10;:17::i;:::-;:21;14910:38;;14963:20;14997:6;14986:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14963:41;;15019:11;15148:6;15144:2;15140:15;15132:6;15128:28;15121:35;;15185:288;15192:4;15185:288;;;15217:5;;;;;;;;15359:8;15354:2;15347:5;15343:14;15338:30;15333:3;15325:44;15415:2;15406:11;;;;;;:::i;:::-;;;;;15449:1;15440:5;:10;15436:21;;;15452:5;;15436:21;15185:288;;;15494:6;15487:13;;;;;14803:716;;;:::o;47797:942::-;47891:1;47877:16;;:2;:16;;;;47869:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;47950:16;47958:7;47950;:16::i;:::-;47949:17;47941:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;48012:48;48041:1;48045:2;48049:7;48058:1;48012:20;:48::i;:::-;48159:16;48167:7;48159;:16::i;:::-;48158:17;48150:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;48574:1;48557:9;:13;48567:2;48557:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;48618:2;48599:7;:16;48607:7;48599:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;48663:7;48659:2;48638:33;;48655:1;48638:33;;;;;;;;;;;;48684:47;48712:1;48716:2;48720:7;48729:1;48684:19;:47::i;:::-;47797:942;;:::o;11669:922::-;11722:7;11742:14;11759:1;11742:18;;11809:6;11800:5;:15;11796:102;;11845:6;11836:15;;;;;;:::i;:::-;;;;;11880:2;11870:12;;;;11796:102;11925:6;11916:5;:15;11912:102;;11961:6;11952:15;;;;;;:::i;:::-;;;;;11996:2;11986:12;;;;11912:102;12041:6;12032:5;:15;12028:102;;12077:6;12068:15;;;;;;:::i;:::-;;;;;12112:2;12102:12;;;;12028:102;12157:5;12148;:14;12144:99;;12192:5;12183:14;;;;;;:::i;:::-;;;;;12226:1;12216:11;;;;12144:99;12270:5;12261;:14;12257:99;;12305:5;12296:14;;;;;;:::i;:::-;;;;;12339:1;12329:11;;;;12257:99;12383:5;12374;:14;12370:99;;12418:5;12409:14;;;;;;:::i;:::-;;;;;12452:1;12442:11;;;;12370:99;12496:5;12487;:14;12483:66;;12532:1;12522:11;;;;12483:66;12577:6;12570:13;;;11669:922;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334: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:619::-;5015:6;5023;5031;5080:2;5068:9;5059:7;5055:23;5051:32;5048:119;;;5086:79;;:::i;:::-;5048:119;5206:1;5231:53;5276:7;5267:6;5256:9;5252:22;5231:53;:::i;:::-;5221:63;;5177:117;5333:2;5359:53;5404:7;5395:6;5384:9;5380:22;5359:53;:::i;:::-;5349:63;;5304:118;5461:2;5487:53;5532:7;5523:6;5512:9;5508:22;5487:53;:::i;:::-;5477:63;;5432:118;4938:619;;;;;:::o;5563:329::-;5622:6;5671:2;5659:9;5650:7;5646:23;5642:32;5639:119;;;5677:79;;:::i;:::-;5639:119;5797:1;5822:53;5867:7;5858:6;5847:9;5843:22;5822:53;:::i;:::-;5812:63;;5768:117;5563:329;;;;:::o;5898:118::-;5985:24;6003:5;5985:24;:::i;:::-;5980:3;5973:37;5898:118;;:::o;6022:222::-;6115:4;6153:2;6142:9;6138:18;6130:26;;6166:71;6234:1;6223:9;6219:17;6210:6;6166:71;:::i;:::-;6022:222;;;;:::o;6250:116::-;6320:21;6335:5;6320:21;:::i;:::-;6313:5;6310:32;6300:60;;6356:1;6353;6346:12;6300:60;6250:116;:::o;6372:133::-;6415:5;6453:6;6440:20;6431:29;;6469:30;6493:5;6469:30;:::i;:::-;6372:133;;;;:::o;6511:468::-;6576:6;6584;6633:2;6621:9;6612:7;6608:23;6604:32;6601:119;;;6639:79;;:::i;:::-;6601:119;6759:1;6784:53;6829:7;6820:6;6809:9;6805:22;6784:53;:::i;:::-;6774:63;;6730:117;6886:2;6912:50;6954:7;6945:6;6934:9;6930:22;6912:50;:::i;:::-;6902:60;;6857:115;6511:468;;;;;:::o;6985:117::-;7094:1;7091;7084:12;7108:117;7217:1;7214;7207:12;7231:180;7279:77;7276:1;7269:88;7376:4;7373:1;7366:15;7400:4;7397:1;7390:15;7417:281;7500:27;7522:4;7500:27;:::i;:::-;7492:6;7488:40;7630:6;7618:10;7615:22;7594:18;7582:10;7579:34;7576:62;7573:88;;;7641:18;;:::i;:::-;7573:88;7681:10;7677:2;7670:22;7460:238;7417:281;;:::o;7704:129::-;7738:6;7765:20;;:::i;:::-;7755:30;;7794:33;7822:4;7814:6;7794:33;:::i;:::-;7704:129;;;:::o;7839:307::-;7900:4;7990:18;7982:6;7979:30;7976:56;;;8012:18;;:::i;:::-;7976:56;8050:29;8072:6;8050:29;:::i;:::-;8042:37;;8134:4;8128;8124:15;8116:23;;7839:307;;;:::o;8152:154::-;8236:6;8231:3;8226;8213:30;8298:1;8289:6;8284:3;8280:16;8273:27;8152:154;;;:::o;8312:410::-;8389:5;8414:65;8430:48;8471:6;8430:48;:::i;:::-;8414:65;:::i;:::-;8405:74;;8502:6;8495:5;8488:21;8540:4;8533:5;8529:16;8578:3;8569:6;8564:3;8560:16;8557:25;8554:112;;;8585:79;;:::i;:::-;8554:112;8675:41;8709:6;8704:3;8699;8675:41;:::i;:::-;8395:327;8312:410;;;;;:::o;8741:338::-;8796:5;8845:3;8838:4;8830:6;8826:17;8822:27;8812:122;;8853:79;;:::i;:::-;8812:122;8970:6;8957:20;8995:78;9069:3;9061:6;9054:4;9046:6;9042:17;8995:78;:::i;:::-;8986:87;;8802:277;8741:338;;;;:::o;9085:943::-;9180:6;9188;9196;9204;9253:3;9241:9;9232:7;9228:23;9224:33;9221:120;;;9260:79;;:::i;:::-;9221:120;9380:1;9405:53;9450:7;9441:6;9430:9;9426:22;9405:53;:::i;:::-;9395:63;;9351:117;9507:2;9533:53;9578:7;9569:6;9558:9;9554:22;9533:53;:::i;:::-;9523:63;;9478:118;9635:2;9661:53;9706:7;9697:6;9686:9;9682:22;9661:53;:::i;:::-;9651:63;;9606:118;9791:2;9780:9;9776:18;9763:32;9822:18;9814:6;9811:30;9808:117;;;9844:79;;:::i;:::-;9808:117;9949:62;10003:7;9994:6;9983:9;9979:22;9949:62;:::i;:::-;9939:72;;9734:287;9085:943;;;;;;;:::o;10034:308::-;10096:4;10186:18;10178:6;10175:30;10172:56;;;10208:18;;:::i;:::-;10172:56;10246:29;10268:6;10246:29;:::i;:::-;10238:37;;10330:4;10324;10320:15;10312:23;;10034:308;;;:::o;10348:412::-;10426:5;10451:66;10467:49;10509:6;10467:49;:::i;:::-;10451:66;:::i;:::-;10442:75;;10540:6;10533:5;10526:21;10578:4;10571:5;10567:16;10616:3;10607:6;10602:3;10598:16;10595:25;10592:112;;;10623:79;;:::i;:::-;10592:112;10713:41;10747:6;10742:3;10737;10713:41;:::i;:::-;10432:328;10348:412;;;;;:::o;10780:340::-;10836:5;10885:3;10878:4;10870:6;10866:17;10862:27;10852:122;;10893:79;;:::i;:::-;10852:122;11010:6;10997:20;11035:79;11110:3;11102:6;11095:4;11087:6;11083:17;11035:79;:::i;:::-;11026:88;;10842:278;10780:340;;;;:::o;11126:654::-;11204:6;11212;11261:2;11249:9;11240:7;11236:23;11232:32;11229:119;;;11267:79;;:::i;:::-;11229:119;11387:1;11412:53;11457:7;11448:6;11437:9;11433:22;11412:53;:::i;:::-;11402:63;;11358:117;11542:2;11531:9;11527:18;11514:32;11573:18;11565:6;11562:30;11559:117;;;11595:79;;:::i;:::-;11559:117;11700:63;11755:7;11746:6;11735:9;11731:22;11700:63;:::i;:::-;11690:73;;11485:288;11126:654;;;;;:::o;11786:474::-;11854:6;11862;11911:2;11899:9;11890:7;11886:23;11882:32;11879:119;;;11917:79;;:::i;:::-;11879:119;12037:1;12062:53;12107:7;12098:6;12087:9;12083:22;12062:53;:::i;:::-;12052:63;;12008:117;12164:2;12190:53;12235:7;12226:6;12215:9;12211:22;12190:53;:::i;:::-;12180:63;;12135:118;11786:474;;;;;:::o;12266:180::-;12314:77;12311:1;12304:88;12411:4;12408:1;12401:15;12435:4;12432:1;12425:15;12452:320;12496:6;12533:1;12527:4;12523:12;12513:22;;12580:1;12574:4;12570:12;12601:18;12591:81;;12657:4;12649:6;12645:17;12635:27;;12591:81;12719:2;12711:6;12708:14;12688:18;12685:38;12682:84;;;12738:18;;:::i;:::-;12682:84;12503:269;12452:320;;;:::o;12778:220::-;12918:34;12914:1;12906:6;12902:14;12895:58;12987:3;12982:2;12974:6;12970:15;12963:28;12778:220;:::o;13004:366::-;13146:3;13167:67;13231:2;13226:3;13167:67;:::i;:::-;13160:74;;13243:93;13332:3;13243:93;:::i;:::-;13361:2;13356:3;13352:12;13345:19;;13004:366;;;:::o;13376:419::-;13542:4;13580:2;13569:9;13565:18;13557:26;;13629:9;13623:4;13619:20;13615:1;13604:9;13600:17;13593:47;13657:131;13783:4;13657:131;:::i;:::-;13649:139;;13376:419;;;:::o;13801:248::-;13941:34;13937:1;13929:6;13925:14;13918:58;14010:31;14005:2;13997:6;13993:15;13986:56;13801:248;:::o;14055:366::-;14197:3;14218:67;14282:2;14277:3;14218:67;:::i;:::-;14211:74;;14294:93;14383:3;14294:93;:::i;:::-;14412:2;14407:3;14403:12;14396:19;;14055:366;;;:::o;14427:419::-;14593:4;14631:2;14620:9;14616:18;14608:26;;14680:9;14674:4;14670:20;14666:1;14655:9;14651:17;14644:47;14708:131;14834:4;14708:131;:::i;:::-;14700:139;;14427:419;;;:::o;14852:232::-;14992:34;14988:1;14980:6;14976:14;14969:58;15061:15;15056:2;15048:6;15044:15;15037:40;14852:232;:::o;15090:366::-;15232:3;15253:67;15317:2;15312:3;15253:67;:::i;:::-;15246:74;;15329:93;15418:3;15329:93;:::i;:::-;15447:2;15442:3;15438:12;15431:19;;15090:366;;;:::o;15462:419::-;15628:4;15666:2;15655:9;15651:18;15643:26;;15715:9;15709:4;15705:20;15701:1;15690:9;15686:17;15679:47;15743:131;15869:4;15743:131;:::i;:::-;15735:139;;15462:419;;;:::o;15887:174::-;16027:26;16023:1;16015:6;16011:14;16004:50;15887:174;:::o;16067:366::-;16209:3;16230:67;16294:2;16289:3;16230:67;:::i;:::-;16223:74;;16306:93;16395:3;16306:93;:::i;:::-;16424:2;16419:3;16415:12;16408:19;;16067:366;;;:::o;16439:419::-;16605:4;16643:2;16632:9;16628:18;16620:26;;16692:9;16686:4;16682:20;16678:1;16667:9;16663:17;16656:47;16720:131;16846:4;16720:131;:::i;:::-;16712:139;;16439:419;;;:::o;16864:228::-;17004:34;17000:1;16992:6;16988:14;16981:58;17073:11;17068:2;17060:6;17056:15;17049:36;16864:228;:::o;17098:366::-;17240:3;17261:67;17325:2;17320:3;17261:67;:::i;:::-;17254:74;;17337:93;17426:3;17337:93;:::i;:::-;17455:2;17450:3;17446:12;17439:19;;17098:366;;;:::o;17470:419::-;17636:4;17674:2;17663:9;17659:18;17651:26;;17723:9;17717:4;17713:20;17709:1;17698:9;17694:17;17687:47;17751:131;17877:4;17751:131;:::i;:::-;17743:139;;17470:419;;;:::o;17895:225::-;18035:34;18031:1;18023:6;18019:14;18012:58;18104:8;18099:2;18091:6;18087:15;18080:33;17895:225;:::o;18126:366::-;18268:3;18289:67;18353:2;18348:3;18289:67;:::i;:::-;18282:74;;18365:93;18454:3;18365:93;:::i;:::-;18483:2;18478:3;18474:12;18467:19;;18126:366;;;:::o;18498:419::-;18664:4;18702:2;18691:9;18687:18;18679:26;;18751:9;18745:4;18741:20;18737:1;18726:9;18722:17;18715:47;18779:131;18905:4;18779:131;:::i;:::-;18771:139;;18498:419;;;:::o;18923:224::-;19063:34;19059:1;19051:6;19047:14;19040:58;19132:7;19127:2;19119:6;19115:15;19108:32;18923:224;:::o;19153:366::-;19295:3;19316:67;19380:2;19375:3;19316:67;:::i;:::-;19309:74;;19392:93;19481:3;19392:93;:::i;:::-;19510:2;19505:3;19501:12;19494:19;;19153:366;;;:::o;19525:419::-;19691:4;19729:2;19718:9;19714:18;19706:26;;19778:9;19772:4;19768:20;19764:1;19753:9;19749:17;19742:47;19806:131;19932:4;19806:131;:::i;:::-;19798:139;;19525:419;;;:::o;19950:223::-;20090:34;20086:1;20078:6;20074:14;20067:58;20159:6;20154:2;20146:6;20142:15;20135:31;19950:223;:::o;20179:366::-;20321:3;20342:67;20406:2;20401:3;20342:67;:::i;:::-;20335:74;;20418:93;20507:3;20418:93;:::i;:::-;20536:2;20531:3;20527:12;20520:19;;20179:366;;;:::o;20551:419::-;20717:4;20755:2;20744:9;20740:18;20732:26;;20804:9;20798:4;20794:20;20790:1;20779:9;20775:17;20768:47;20832:131;20958:4;20832:131;:::i;:::-;20824:139;;20551:419;;;:::o;20976:182::-;21116:34;21112:1;21104:6;21100:14;21093:58;20976:182;:::o;21164:366::-;21306:3;21327:67;21391:2;21386:3;21327:67;:::i;:::-;21320:74;;21403:93;21492:3;21403:93;:::i;:::-;21521:2;21516:3;21512:12;21505:19;;21164:366;;;:::o;21536:419::-;21702:4;21740:2;21729:9;21725:18;21717:26;;21789:9;21783:4;21779:20;21775:1;21764:9;21760:17;21753:47;21817:131;21943:4;21817:131;:::i;:::-;21809:139;;21536:419;;;:::o;21961:175::-;22101:27;22097:1;22089:6;22085:14;22078:51;21961:175;:::o;22142:366::-;22284:3;22305:67;22369:2;22364:3;22305:67;:::i;:::-;22298:74;;22381:93;22470:3;22381:93;:::i;:::-;22499:2;22494:3;22490:12;22483:19;;22142:366;;;:::o;22514:419::-;22680:4;22718:2;22707:9;22703:18;22695:26;;22767:9;22761:4;22757:20;22753:1;22742:9;22738:17;22731:47;22795:131;22921:4;22795:131;:::i;:::-;22787:139;;22514:419;;;:::o;22939:237::-;23079:34;23075:1;23067:6;23063:14;23056:58;23148:20;23143:2;23135:6;23131:15;23124:45;22939:237;:::o;23182:366::-;23324:3;23345:67;23409:2;23404:3;23345:67;:::i;:::-;23338:74;;23421:93;23510:3;23421:93;:::i;:::-;23539:2;23534:3;23530:12;23523:19;;23182:366;;;:::o;23554:419::-;23720:4;23758:2;23747:9;23743:18;23735:26;;23807:9;23801:4;23797:20;23793:1;23782:9;23778:17;23771:47;23835:131;23961:4;23835:131;:::i;:::-;23827:139;;23554:419;;;:::o;23979:148::-;24081:11;24118:3;24103:18;;23979:148;;;;:::o;24133:377::-;24239:3;24267:39;24300:5;24267:39;:::i;:::-;24322:89;24404:6;24399:3;24322:89;:::i;:::-;24315:96;;24420:52;24465:6;24460:3;24453:4;24446:5;24442:16;24420:52;:::i;:::-;24497:6;24492:3;24488:16;24481:23;;24243:267;24133:377;;;;:::o;24516:435::-;24696:3;24718:95;24809:3;24800:6;24718:95;:::i;:::-;24711:102;;24830:95;24921:3;24912:6;24830:95;:::i;:::-;24823:102;;24942:3;24935:10;;24516:435;;;;;:::o;24957:233::-;25097:34;25093:1;25085:6;25081:14;25074:58;25166:16;25161:2;25153:6;25149:15;25142:41;24957:233;:::o;25196:366::-;25338:3;25359:67;25423:2;25418:3;25359:67;:::i;:::-;25352:74;;25435:93;25524:3;25435:93;:::i;:::-;25553:2;25548:3;25544:12;25537:19;;25196:366;;;:::o;25568:419::-;25734:4;25772:2;25761:9;25757:18;25749:26;;25821:9;25815:4;25811:20;25807:1;25796:9;25792:17;25785:47;25849:131;25975:4;25849:131;:::i;:::-;25841:139;;25568:419;;;:::o;25993:180::-;26041:77;26038:1;26031:88;26138:4;26135:1;26128:15;26162:4;26159:1;26152:15;26179:191;26219:4;26239:20;26257:1;26239:20;:::i;:::-;26234:25;;26273:20;26291:1;26273:20;:::i;:::-;26268:25;;26312:1;26309;26306:8;26303:34;;;26317:18;;:::i;:::-;26303:34;26362:1;26359;26355:9;26347:17;;26179:191;;;;:::o;26376:305::-;26416:3;26435:20;26453:1;26435:20;:::i;:::-;26430:25;;26469:20;26487:1;26469:20;:::i;:::-;26464:25;;26623:1;26555:66;26551:74;26548:1;26545:81;26542:107;;;26629:18;;:::i;:::-;26542:107;26673:1;26670;26666:9;26659:16;;26376:305;;;;:::o;26687:98::-;26738:6;26772:5;26766:12;26756:22;;26687:98;;;:::o;26791:168::-;26874:11;26908:6;26903:3;26896:19;26948:4;26943:3;26939:14;26924:29;;26791:168;;;;:::o;26965:360::-;27051:3;27079:38;27111:5;27079:38;:::i;:::-;27133:70;27196:6;27191:3;27133:70;:::i;:::-;27126:77;;27212:52;27257:6;27252:3;27245:4;27238:5;27234:16;27212:52;:::i;:::-;27289:29;27311:6;27289:29;:::i;:::-;27284:3;27280:39;27273:46;;27055:270;26965:360;;;;:::o;27331:640::-;27526:4;27564:3;27553:9;27549:19;27541:27;;27578:71;27646:1;27635:9;27631:17;27622:6;27578:71;:::i;:::-;27659:72;27727:2;27716:9;27712:18;27703:6;27659:72;:::i;:::-;27741;27809:2;27798:9;27794:18;27785:6;27741:72;:::i;:::-;27860:9;27854:4;27850:20;27845:2;27834:9;27830:18;27823:48;27888:76;27959:4;27950:6;27888:76;:::i;:::-;27880:84;;27331:640;;;;;;;:::o;27977:141::-;28033:5;28064:6;28058:13;28049:22;;28080:32;28106:5;28080:32;:::i;:::-;27977:141;;;;:::o;28124:349::-;28193:6;28242:2;28230:9;28221:7;28217:23;28213:32;28210:119;;;28248:79;;:::i;:::-;28210:119;28368:1;28393:63;28448:7;28439:6;28428:9;28424:22;28393:63;:::i;:::-;28383:73;;28339:127;28124:349;;;;:::o;28479:180::-;28527:77;28524:1;28517:88;28624:4;28621:1;28614:15;28648:4;28645:1;28638:15;28665:182;28805:34;28801:1;28793:6;28789:14;28782:58;28665:182;:::o;28853:366::-;28995:3;29016:67;29080:2;29075:3;29016:67;:::i;:::-;29009:74;;29092:93;29181:3;29092:93;:::i;:::-;29210:2;29205:3;29201:12;29194:19;;28853:366;;;:::o;29225:419::-;29391:4;29429:2;29418:9;29414:18;29406:26;;29478:9;29472:4;29468:20;29464:1;29453:9;29449:17;29442:47;29506:131;29632:4;29506:131;:::i;:::-;29498:139;;29225:419;;;:::o;29650:178::-;29790:30;29786:1;29778:6;29774:14;29767:54;29650:178;:::o;29834:366::-;29976:3;29997:67;30061:2;30056:3;29997:67;:::i;:::-;29990:74;;30073:93;30162:3;30073:93;:::i;:::-;30191:2;30186:3;30182:12;30175:19;;29834:366;;;:::o;30206:419::-;30372:4;30410:2;30399:9;30395:18;30387:26;;30459:9;30453:4;30449:20;30445:1;30434:9;30430:17;30423:47;30487:131;30613:4;30487:131;:::i;:::-;30479:139;;30206:419;;;:::o

ipfs://3af6a929d3c248c75a8cb4035b3a21f6efdcff19c923309d007d0d013d36b407