Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Nova.Arbiscan.io on 2023-04-10
*/

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


// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides a set of functions to operate with Base64 strings.
 *
 * _Available since v4.5._
 */
library Base64 {
    /**
     * @dev Base64 Encoding/Decoding Table
     */
    string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /**
     * @dev Converts a `bytes` to its Bytes64 `string` representation.
     */
    function encode(bytes memory data) internal pure returns (string memory) {
        /**
         * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence
         * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol
         */
        if (data.length == 0) return "";

        // Loads the table into memory
        string memory table = _TABLE;

        // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter
        // and split into 4 numbers of 6 bits.
        // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up
        // - `data.length + 2`  -> Round up
        // - `/ 3`              -> Number of 3-bytes chunks
        // - `4 *`              -> 4 characters for each chunk
        string memory result = new string(4 * ((data.length + 2) / 3));

        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the lookup table (skip the first "length" byte)
            let tablePtr := add(table, 1)

            // Prepare result pointer, jump over length
            let resultPtr := add(result, 32)

            // Run over the input, 3 bytes at a time
            for {
                let dataPtr := data
                let endPtr := add(data, mload(data))
            } lt(dataPtr, endPtr) {

            } {
                // Advance 3 bytes
                dataPtr := add(dataPtr, 3)
                let input := mload(dataPtr)

                // To write each character, shift the 3 bytes (18 bits) chunk
                // 4 times in blocks of 6 bits for each character (18, 12, 6, 0)
                // and apply logical AND with 0x3F which is the number of
                // the previous character in the ASCII table prior to the Base64 Table
                // The result is then added to the table to get the character to write,
                // and finally write it in the result pointer but with a left shift
                // of 256 (1 byte) - 8 (1 ASCII char) = 248 bits

                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance
            }

            // When data `bytes` is not exactly 3 bytes long
            // it is padded with `=` characters at the end
            switch mod(mload(data), 3)
            case 1 {
                mstore8(sub(resultPtr, 1), 0x3d)
                mstore8(sub(resultPtr, 2), 0x3d)
            }
            case 2 {
                mstore8(sub(resultPtr, 1), 0x3d)
            }
        }

        return result;
    }
}

// File: Extra/StringUtils.sol


pragma solidity ^0.8.0;

/**
 * Strings Library
 * 
 * In summary this is a simple library of string functions which make simple 
 * string operations less tedious in solidity.
 * 
 * Please be aware these functions can be quite gas heavy so use them only when
 * necessary not to clog the blockchain with expensive transactions.
 * 
 * @author James Lockhart <[email protected]>
 */
library StringUtils {

    /**
     * Concat (High gas cost)
     * 
     * Appends two strings together and returns a new value
     * 
     * @param _base When being used for a data type this is the extended object
     *              otherwise this is the string which will be the concatenated
     *              prefix
     * @param _value The value to be the concatenated suffix
     * @return string The resulting string from combinging the base and value
     */
    function concat(string memory _base, string memory _value)
        internal
        pure
        returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        assert(_valueBytes.length > 0);

        string memory _tmpValue = new string(_baseBytes.length +
            _valueBytes.length);
        bytes memory _newValue = bytes(_tmpValue);

        uint i;
        uint j;

        for (i = 0; i < _baseBytes.length; i++) {
            _newValue[j++] = _baseBytes[i];
        }

        for (i = 0; i < _valueBytes.length; i++) {
            _newValue[j++] = _valueBytes[i];
        }

        return string(_newValue);
    }

    /**
     * Index Of
     *
     * Locates and returns the position of a character within a string
     * 
     * @param _base When being used for a data type this is the extended object
     *              otherwise this is the string acting as the haystack to be
     *              searched
     * @param _value The needle to search for, at present this is currently
     *               limited to one character
     * @return int The position of the needle starting from 0 and returning -1
     *             in the case of no matches found
     */
    function indexOf(string memory _base, string memory _value)
        internal
        pure
        returns (int) {
        return _indexOf(_base, _value, 0);
    }

    /**
     * Index Of
     *
     * Locates and returns the position of a character within a string starting
     * from a defined offset
     * 
     * @param _base When being used for a data type this is the extended object
     *              otherwise this is the string acting as the haystack to be
     *              searched
     * @param _value The needle to search for, at present this is currently
     *               limited to one character
     * @param _offset The starting point to start searching from which can start
     *                from 0, but must not exceed the length of the string
     * @return int The position of the needle starting from 0 and returning -1
     *             in the case of no matches found
     */
    function _indexOf(string memory _base, string memory _value, uint _offset)
        internal
        pure
        returns (int) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        assert(_valueBytes.length == 1);

        for (uint i = _offset; i < _baseBytes.length; i++) {
            if (_baseBytes[i] == _valueBytes[0]) {
                return int(i);
            }
        }

        return -1;
    }

    /**
     * Length
     * 
     * Returns the length of the specified string
     * 
     * @param _base When being used for a data type this is the extended object
     *              otherwise this is the string to be measured
     * @return uint The length of the passed string
     */
    function length(string memory _base)
        internal
        pure
        returns (uint) {
        bytes memory _baseBytes = bytes(_base);
        return _baseBytes.length;
    }

    /**
     * Sub String
     * 
     * Extracts the beginning part of a string based on the desired length
     * 
     * @param _base When being used for a data type this is the extended object
     *              otherwise this is the string that will be used for 
     *              extracting the sub string from
     * @param _length The length of the sub string to be extracted from the base
     * @return string The extracted sub string
     */
    function substring(string memory _base, int _length)
        internal
        pure
        returns (string memory) {
        return _substring(_base, _length, 0);
    }

    /**
     * Sub String
     * 
     * Extracts the part of a string based on the desired length and offset. The
     * offset and length must not exceed the lenth of the base string.
     * 
     * @param _base When being used for a data type this is the extended object
     *              otherwise this is the string that will be used for 
     *              extracting the sub string from
     * @param _length The length of the sub string to be extracted from the base
     * @param _offset The starting point to extract the sub string from
     * @return string The extracted sub string
     */
    function _substring(string memory _base, int _length, int _offset)
        internal
        pure
        returns (string memory) {
        bytes memory _baseBytes = bytes(_base);

        assert(uint(_offset + _length) <= _baseBytes.length);

        string memory _tmp = new string(uint(_length));
        bytes memory _tmpBytes = bytes(_tmp);

        uint j = 0;
        for (uint i = uint(_offset); i < uint(_offset + _length); i++) {
            _tmpBytes[j++] = _baseBytes[i];
        }

        return string(_tmpBytes);
    }


    function split(string memory _base, string memory _value)
        internal
        pure
        returns (string[] memory splitArr) {
        bytes memory _baseBytes = bytes(_base);

        uint _offset = 0;
        uint _splitsCount = 1;
        while (_offset < _baseBytes.length - 1) {
            int _limit = _indexOf(_base, _value, _offset);
            if (_limit == -1)
                break;
            else {
                _splitsCount++;
                _offset = uint(_limit) + 1;
            }
        }

        splitArr = new string[](_splitsCount);

        _offset = 0;
        _splitsCount = 0;
        while (_offset < _baseBytes.length - 1) {

            int _limit = _indexOf(_base, _value, _offset);
            if (_limit == - 1) {
                _limit = int(_baseBytes.length);
            }

            string memory _tmp = new string(uint(_limit) - _offset);
            bytes memory _tmpBytes = bytes(_tmp);

            uint j = 0;
            for (uint i = _offset; i < uint(_limit); i++) {
                _tmpBytes[j++] = _baseBytes[i];
            }
            _offset = uint(_limit) + 1;
            splitArr[_splitsCount++] = string(_tmpBytes);
        }
        return splitArr;
    }

    /**
     * Compare To
     * 
     * Compares the characters of two strings, to ensure that they have an 
     * identical footprint
     * 
     * @param _base When being used for a data type this is the extended object
     *               otherwise this is the string base to compare against
     * @param _value The string the base is being compared to
     * @return bool Simply notates if the two string have an equivalent
     */
    function compareTo(string memory _base, string memory _value)
        internal
        pure
        returns (bool) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        if (_baseBytes.length != _valueBytes.length) {
            return false;
        }

        for (uint i = 0; i < _baseBytes.length; i++) {
            if (_baseBytes[i] != _valueBytes[i]) {
                return false;
            }
        }

        return true;
    }

    /**
     * Compare To Ignore Case (High gas cost)
     * 
     * Compares the characters of two strings, converting them to the same case
     * where applicable to alphabetic characters to distinguish if the values
     * match.
     * 
     * @param _base When being used for a data type this is the extended object
     *               otherwise this is the string base to compare against
     * @param _value The string the base is being compared to
     * @return bool Simply notates if the two string have an equivalent value
     *              discarding case
     */
    function compareToIgnoreCase(string memory _base, string memory _value)
        internal
        pure
        returns (bool) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        if (_baseBytes.length != _valueBytes.length) {
            return false;
        }

        for (uint i = 0; i < _baseBytes.length; i++) {
            if (_baseBytes[i] != _valueBytes[i] &&
            _upper(_baseBytes[i]) != _upper(_valueBytes[i])) {
                return false;
            }
        }

        return true;
    }

    /**
     * Upper
     * 
     * Converts all the values of a string to their corresponding upper case
     * value.
     * 
     * @param _base When being used for a data type this is the extended object
     *              otherwise this is the string base to convert to upper case
     * @return string 
     */
    function upper(string memory _base)
        internal
        pure
        returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        for (uint i = 0; i < _baseBytes.length; i++) {
            _baseBytes[i] = _upper(_baseBytes[i]);
        }
        return string(_baseBytes);
    }

    /**
     * Lower
     * 
     * Converts all the values of a string to their corresponding lower case
     * value.
     * 
     * @param _base When being used for a data type this is the extended object
     *              otherwise this is the string base to convert to lower case
     * @return string 
     */
    function lower(string memory _base)
        internal
        pure
        returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        for (uint i = 0; i < _baseBytes.length; i++) {
            _baseBytes[i] = _lower(_baseBytes[i]);
        }
        return string(_baseBytes);
    }

    /**
     * Upper
     * 
     * Convert an alphabetic character to upper case and return the original
     * value when not alphabetic
     * 
     * @param _b1 The byte to be converted to upper case
     * @return bytes1 The converted value if the passed value was alphabetic
     *                and in a lower case otherwise returns the original value
     */
    function _upper(bytes1 _b1)
        private
        pure
        returns (bytes1) {

        if (_b1 >= 0x61 && _b1 <= 0x7A) {
            return bytes1(uint8(_b1) - 32);
        }

        return _b1;
    }

    /**
     * Lower
     * 
     * Convert an alphabetic character to lower case and return the original
     * value when not alphabetic
     * 
     * @param _b1 The byte to be converted to lower case
     * @return bytes1 The converted value if the passed value was alphabetic
     *                and in a upper case otherwise returns the original value
     */
    function _lower(bytes1 _b1)
        private
        pure
        returns (bytes1) {

        if (_b1 >= 0x41 && _b1 <= 0x5A) {
            return bytes1(uint8(_b1) + 32);
        }

        return _b1;
    }
}
// File: Extra/DynamicBuffer.sol


// Copyright (c) 2021 the ethier authors (github.com/divergencetech/ethier)

pragma solidity >=0.8.0;

/// @title DynamicBuffer
/// @author David Huber (@cxkoda) and Simon Fremaux (@dievardump). See also
///         https://raw.githubusercontent.com/dievardump/solidity-dynamic-buffer
/// @notice This library is used to allocate a big amount of container memory
//          which will be subsequently filled without needing to reallocate
///         memory.
/// @dev First, allocate memory.
///      Then use `buffer.appendUnchecked(theBytes)` or `appendSafe()` if
///      bounds checking is required.
library DynamicBuffer {
    /// @notice Allocates container space for the DynamicBuffer
    /// @param capacity The intended max amount of bytes in the buffer
    /// @return buffer The memory location of the buffer
    /// @dev Allocates `capacity + 0x60` bytes of space
    ///      The buffer array starts at the first container data position,
    ///      (i.e. `buffer = container + 0x20`)
    function allocate(uint256 capacity)
        internal
        pure
        returns (bytes memory buffer)
    {
        assembly {
            // Get next-free memory address
            let container := mload(0x40)

            // Allocate memory by setting a new next-free address
            {
                // Add 2 x 32 bytes in size for the two length fields
                // Add 32 bytes safety space for 32B chunked copy
                let size := add(capacity, 0x60)
                let newNextFree := add(container, size)
                mstore(0x40, newNextFree)
            }

            // Set the correct container length
            {
                let length := add(capacity, 0x40)
                mstore(container, length)
            }

            // The buffer starts at idx 1 in the container (0 is length)
            buffer := add(container, 0x20)

            // Init content with length 0
            mstore(buffer, 0)
        }

        return buffer;
    }

    /// @notice Appends data to buffer, and update buffer length
    /// @param buffer the buffer to append the data to
    /// @param data the data to append
    /// @dev Does not perform out-of-bound checks (container capacity)
    ///      for efficiency.
    function appendUnchecked(bytes memory buffer, bytes memory data)
        internal
        pure
    {
        assembly {
            let length := mload(data)
            for {
                data := add(data, 0x20)
                let dataEnd := add(data, length)
                let copyTo := add(buffer, add(mload(buffer), 0x20))
            } lt(data, dataEnd) {
                data := add(data, 0x20)
                copyTo := add(copyTo, 0x20)
            } {
                // Copy 32B chunks from data to buffer.
                // This may read over data array boundaries and copy invalid
                // bytes, which doesn't matter in the end since we will
                // later set the correct buffer length, and have allocated an
                // additional word to avoid buffer overflow.
                mstore(copyTo, mload(data))
            }

            // Update buffer length
            mstore(buffer, add(mload(buffer), length))
        }
    }

    /// @notice Appends data to buffer, and update buffer length
    /// @param buffer the buffer to append the data to
    /// @param data the data to append
    /// @dev Performs out-of-bound checks and calls `appendUnchecked`.
    function appendSafe(bytes memory buffer, bytes memory data) internal pure {
        uint256 capacity;
        uint256 length;
        assembly {
            capacity := sub(mload(sub(buffer, 0x20)), 0x40)
            length := mload(buffer)
        }

        require(
            length + data.length <= capacity,
            "DynamicBuffer: Appending out of bounds."
        );
        appendUnchecked(buffer, data);
    }
}
// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// 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: /Contracts/ERC721R.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. This does random batch minting.
 */
contract ERC721r is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;
    
    mapping(uint => uint) private _availableTokens;
    uint256 private _numAvailableTokens;
    uint256 immutable _maxSupply;
    // 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_, uint maxSupply_) {
        _name = name_;
        _symbol = symbol_;
        _maxSupply = maxSupply_;
        _numAvailableTokens = maxSupply_;
    }
    
    /**
     * @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);
    }
    
    function totalSupply() public view virtual returns (uint256) {
        return _maxSupply - _numAvailableTokens;
    }
    
    function maxSupply() public view virtual returns (uint256) {
        return _maxSupply;
    }

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        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) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        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 = ERC721r.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        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: transfer caller is not owner nor 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: transfer caller is not owner nor 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 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 _owners[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) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721r.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    function _mintIdWithoutBalanceUpdate(address to, uint256 tokenId) private {
        _beforeTokenTransfer(address(0), to, tokenId);
        
        _owners[tokenId] = to;
        
        emit Transfer(address(0), to, tokenId);
        
        _afterTokenTransfer(address(0), to, tokenId);
    }

    function _mintRandom(address to, uint _numToMint) internal virtual {
        require(_msgSender() == tx.origin, "Contracts cannot mint");
        require(to != address(0), "ERC721: mint to the zero address");
        require(_numToMint > 0, "ERC721r: need to mint at least one token");
        
        // TODO: Probably don't need this as it will underflow and revert automatically in this case
        require(_numAvailableTokens >= _numToMint, "ERC721r: minting more tokens than available");
        
        uint updatedNumAvailableTokens = _numAvailableTokens;
        for (uint256 i; i < _numToMint; ++i) { // Do this ++ unchecked?
            uint256 tokenId = getRandomAvailableTokenId(to, updatedNumAvailableTokens);
            
            _mintIdWithoutBalanceUpdate(to, tokenId);
            
            --updatedNumAvailableTokens;
        }
        
        _numAvailableTokens = updatedNumAvailableTokens;
        _balances[to] += _numToMint;
    }
        
    function getRandomAvailableTokenId(address to, uint updatedNumAvailableTokens)
        internal
        returns (uint256)
    {
        uint256 randomNum = uint256(
            keccak256(
                abi.encode(
                    to,
                    // tx.gasprice,
                    block.number,
                    // block.timestamp,
                    // block.difficulty,
                    // blockhash(block.number - 1),
                    address(this),
                    updatedNumAvailableTokens
                )
            )
        );
        uint256 randomIndex = randomNum % updatedNumAvailableTokens;
        return getAvailableTokenAtIndex(randomIndex, updatedNumAvailableTokens);
    }

    // Implements https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle. Code taken from CryptoPhunksV2
    function getAvailableTokenAtIndex(uint256 indexToUse, uint updatedNumAvailableTokens)
        internal
        returns (uint256)
    {
        uint256 valAtIndex = _availableTokens[indexToUse];
        uint256 result;
        if (valAtIndex == 0) {
            // This means the index itself is still an available token
            result = indexToUse;
        } else {
            // This means the index itself is not an available token, but the val at that index is.
            result = valAtIndex;
        }

        uint256 lastIndex = updatedNumAvailableTokens - 1;
        uint256 lastValInArray = _availableTokens[lastIndex];
        if (indexToUse != lastIndex) {
            // Replace the value at indexToUse, now that it's been used.
            // Replace it with the data from the last index in the array, since we are going to decrease the array size afterwards.
            if (lastValInArray == 0) {
                // This means the index itself is still an available token
                _availableTokens[indexToUse] = lastIndex;
            } else {
                // This means the index itself is not an available token, but the val at that index is.
                _availableTokens[indexToUse] = lastValInArray;
            }
        }
        if (lastValInArray != 0) {
            // Gas refund courtsey of @dievardump
            delete _availableTokens[lastIndex];
        }
        
        return result;
    }
    
    // Not as good as minting a specific tokenId, but will behave the same at the start
    // allowing you to explicitly mint some tokens at launch.
    function _mintAtIndex(address to, uint index) internal virtual {
        require(_msgSender() == tx.origin, "Contracts cannot mint");
        require(to != address(0), "ERC721: mint to the zero address");
        require(_numAvailableTokens >= 1, "ERC721r: minting more tokens than available");
        
        uint tokenId = getAvailableTokenAtIndex(index, _numAvailableTokens);
        --_numAvailableTokens;
        
        _mintIdWithoutBalanceUpdate(to, tokenId);
        
        _balances[to] += 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(ERC721r.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {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 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 {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}
// File: Mint Contract/PunksOnNova.sol










pragma solidity ^0.8.17;

interface PunkDataInterface {
    function punkImage(uint16 index) external view returns (bytes memory);
    function punkAttributes(uint16 index) external view returns (string memory);
}

interface ExtendedPunkDataInterface {
        enum PunkAttributeType {SEX, HAIR, EYES, BEARD, EARS, LIPS, MOUTH, FACE, EMOTION, NECK, NOSE, CHEEKS, TEETH}

        enum PunkAttributeValue {
                NONE, ALIEN, APE, BANDANA, BEANIE, BIG_BEARD, BIG_SHADES, BLACK_LIPSTICK, BLONDE_BOB, 
                BLONDE_SHORT, BLUE_EYE_SHADOW, BUCK_TEETH, CAP, CAP_FORWARD, CHINSTRAP, CHOKER, CIGARETTE, CLASSIC_SHADES, 
                CLOWN_EYES_BLUE, CLOWN_EYES_GREEN, CLOWN_HAIR_GREEN, CLOWN_NOSE, COWBOY_HAT, CRAZY_HAIR, DARK_HAIR, DO_RAG, EARRING,
                EYE_MASK, EYE_PATCH, FEDORA, FEMALE, FRONT_BEARD, FRONT_BEARD_DARK, FROWN, FRUMPY_HAIR, GOAT, GOLD_CHAIN,
                GREEN_EYE_SHADOW, HALF_SHAVED, HANDLEBARS, HEADBAND, HOODIE, HORNED_RIM_GLASSES, HOT_LIPSTICK, KNITTED_CAP,
                LUXURIOUS_BEARD, MALE, MEDICAL_MASK, MESSY_HAIR, MOHAWK, MOHAWK_DARK, MOHAWK_THIN, MOLE, MUSTACHE, MUTTONCHOPS,
                NERD_GLASSES, NORMAL_BEARD, NORMAL_BEARD_BLACK, ORANGE_SIDE, PEAK_SPIKE, PIGTAILS, PILOT_HELMET, PINK_WITH_HAT,
                PIPE, POLICE_CAP, PURPLE_EYE_SHADOW, PURPLE_HAIR, PURPLE_LIPSTICK, RED_MOHAWK, REGULAR_SHADES, ROSY_CHEEKS,
                SHADOW_BEARD, SHAVED_HEAD, SILVER_CHAIN, SMALL_SHADES, SMILE, SPOTS, STRAIGHT_HAIR, STRAIGHT_HAIR_BLONDE,
                STRAIGHT_HAIR_DARK, STRINGY_HAIR, TASSLE_HAT, THREE_D_GLASSES, TIARA, TOP_HAT, VAMPIRE_HAIR, VAPE, VR,
                WELDING_GOGGLES, WILD_BLONDE, WILD_HAIR, WILD_WHITE_HAIR, ZOMBIE
                }


    function attrStringToEnumMapping(string memory) external view returns (ExtendedPunkDataInterface.PunkAttributeValue);
    function attrEnumToStringMapping(PunkAttributeValue) external view returns (string memory);
    function attrValueToTypeEnumMapping(PunkAttributeValue) external view returns (ExtendedPunkDataInterface.PunkAttributeType);
}

contract PunksonNova is ERC721r, Ownable, ReentrancyGuard  {

/// On Chain variables

enum PunkAttributeType {SEX, HAIR, EYES, BEARD, EARS, LIPS, MOUTH, FACE, EMOTION, NECK, NOSE, CHEEKS, TEETH}

    enum PunkAttributeValue {
                NONE, ALIEN, APE, BANDANA, BEANIE, BIG_BEARD, BIG_SHADES, BLACK_LIPSTICK, BLONDE_BOB, 
                BLONDE_SHORT, BLUE_EYE_SHADOW, BUCK_TEETH, CAP, CAP_FORWARD, CHINSTRAP, CHOKER, CIGARETTE, CLASSIC_SHADES, 
                CLOWN_EYES_BLUE, CLOWN_EYES_GREEN, CLOWN_HAIR_GREEN, CLOWN_NOSE, COWBOY_HAT, CRAZY_HAIR, DARK_HAIR, DO_RAG, EARRING,
                EYE_MASK, EYE_PATCH, FEDORA, FEMALE, FRONT_BEARD, FRONT_BEARD_DARK, FROWN, FRUMPY_HAIR, GOAT, GOLD_CHAIN,
                GREEN_EYE_SHADOW, HALF_SHAVED, HANDLEBARS, HEADBAND, HOODIE, HORNED_RIM_GLASSES, HOT_LIPSTICK, KNITTED_CAP,
                LUXURIOUS_BEARD, MALE, MEDICAL_MASK, MESSY_HAIR, MOHAWK, MOHAWK_DARK, MOHAWK_THIN, MOLE, MUSTACHE, MUTTONCHOPS,
                NERD_GLASSES, NORMAL_BEARD, NORMAL_BEARD_BLACK, ORANGE_SIDE, PEAK_SPIKE, PIGTAILS, PILOT_HELMET, PINK_WITH_HAT,
                PIPE, POLICE_CAP, PURPLE_EYE_SHADOW, PURPLE_HAIR, PURPLE_LIPSTICK, RED_MOHAWK, REGULAR_SHADES, ROSY_CHEEKS,
                SHADOW_BEARD, SHAVED_HEAD, SILVER_CHAIN, SMALL_SHADES, SMILE, SPOTS, STRAIGHT_HAIR, STRAIGHT_HAIR_BLONDE,
                STRAIGHT_HAIR_DARK, STRINGY_HAIR, TASSLE_HAT, THREE_D_GLASSES, TIARA, TOP_HAT, VAMPIRE_HAIR, VAPE, VR,
                WELDING_GOGGLES, WILD_BLONDE, WILD_HAIR, WILD_WHITE_HAIR, ZOMBIE
    }

                
    struct Punk {
        uint16 id;
        PunkAttributeValue sex;
        PunkAttributeValue hair;
        PunkAttributeValue eyes;
        PunkAttributeValue beard;
        PunkAttributeValue ears;
        PunkAttributeValue lips;
        PunkAttributeValue mouth;
        PunkAttributeValue face;
        PunkAttributeValue emotion;
        PunkAttributeValue neck;
        PunkAttributeValue nose;
        PunkAttributeValue cheeks;
        PunkAttributeValue teeth;
    }

    using StringUtils for string;
    using Address for address;
    using DynamicBuffer for bytes;
    using Strings for uint256;
    using Strings for uint16;
    using Strings for uint8;

    bytes private constant tokenDescription = "Punks on Arbitrum - Nova Edition - Fully stored on Chain";

    PunkDataInterface private immutable punkDataContract;
    ExtendedPunkDataInterface private immutable extendedPunkDataContract;


    uint     public publicMintPrice    = 0.001 ether;
    bool     public publicMintEnabled  = false;
    bool     public punkMintEnabled    = false;
    uint     public PunksClaimed       = 0;
    uint     public softReserve        = 5000;


    

    address payable public deployer;
    mapping(address => bool) public PunkMinter;
    mapping(address => uint) public MintAmount;

    modifier onlyDeployer() {
        require(tx.origin == deployer, "Only deployer.");
        _;
    }

    constructor(address punkDataContractAddress, address extendedPunkDataContractAddress) 
    ERC721r("Punks on Arbitrum - Nova Edition", "NPUNK", 10000) {

        punkDataContract = PunkDataInterface(punkDataContractAddress);
        extendedPunkDataContract = ExtendedPunkDataInterface(extendedPunkDataContractAddress);

        deployer = payable(msg.sender);


    }
    

    function mint(uint256 count) public payable  {
        
        require(publicMintEnabled, "Mint not ready yet");

        uint256 cost = publicMintPrice;
        require(msg.value >= count * cost, "Please send the exact ETH amount");

        require(totalSupply() + count <= maxSupply(), "Sold Out!");
        require(totalSupply() + count <= softReserve, "Reserved - come back later!");

        require(msg.sender == tx.origin, "The minter is another contract");

        _mintRandom(msg.sender, count);

    }

    function claim_punks() public payable {

        require(punkMintEnabled, "Mint not ready yet");
        require(PunkMinter[msg.sender] == true, "Free Mint already claimed");
        require(msg.value == publicMintPrice, "Please send the exact ETH amount");

        uint count = MintAmount[msg.sender] + 1;
        require(msg.sender == tx.origin, "The minter is another contract");
        require(totalSupply() + count <= maxSupply(), "Sold Out!");

        /// Remove Punk Minter
        PunkMinter[msg.sender] = false;
        PunksClaimed = PunksClaimed + count;

        // Mint Tokens
        _mintRandom(msg.sender, count);

    }


    function toggle_PublicMinting() public onlyOwner {
        publicMintEnabled = !publicMintEnabled;
    }

    function toggle_PunkMinting() public onlyOwner {
        punkMintEnabled = !punkMintEnabled;
    }

    function withdraw() external onlyOwner nonReentrant {
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }

    function team_mint(uint count) external onlyOwner {
        _mintRandom(msg.sender, count);
    }

    function set_reserve(uint _count) external onlyOwner {
        softReserve = _count;
    }


    function load_holder(address holder, uint mintcount) public onlyDeployer {
        PunkMinter[holder] = true;
        MintAmount[holder] = mintcount;
    }


// OnChain Metadata Functions

    function exists(uint tokenId) external view returns (bool) {
        return _exists(tokenId);
    }

    function tokenURI(uint256 id) public view override returns (string memory) {
        require(_exists(id), "Token does not exist");
        return constructTokenURI(uint16(id));
    }

    function constructTokenURI(uint16 tokenId) private view returns (string memory) {
        bytes memory svg = bytes(tokenImage(tokenId));
        bytes memory title = abi.encodePacked("NovaPunk #", tokenId.toString());
        
        return
            string(
                abi.encodePacked(
                    "data:application/json;base64,",
                    Base64.encode(
                        bytes(
                            abi.encodePacked(
                                '{',
                                '"name":"', title, '",'
                                '"description":"', tokenDescription, '",'
                                '"background_color":"ef821f",'
                                '"image_data":"data:image/svg+xml;base64,', Base64.encode(svg), '",'
                                '"attributes": ',
                                punkAttributesAsJSON(tokenId), 
                                '}'
                            )
                        )
                    )
                )
            );
    }

    function initializePunk(uint16 punkId) private view returns (Punk memory) {
        Punk memory punk = Punk({
            id: punkId,
            sex: PunkAttributeValue.NONE,
            hair: PunkAttributeValue.NONE,
            eyes: PunkAttributeValue.NONE,
            beard: PunkAttributeValue.NONE,
            ears: PunkAttributeValue.NONE,
            lips: PunkAttributeValue.NONE,
            mouth: PunkAttributeValue.NONE,
            face: PunkAttributeValue.NONE,
            emotion: PunkAttributeValue.NONE,
            neck: PunkAttributeValue.NONE,
            nose: PunkAttributeValue.NONE,
            cheeks: PunkAttributeValue.NONE,
            teeth: PunkAttributeValue.NONE
        });
        
        punk.id = punkId;
        
        string memory attributes = punkDataContract.punkAttributes(punk.id);

        string[] memory attributeArray = attributes.split(",");
        
        for (uint i = 0; i < attributeArray.length; i++) {
            string memory untrimmedAttribute = attributeArray[i];
            string memory trimmedAttribute;
            
            if (i < 1) {
                trimmedAttribute = untrimmedAttribute.split(' ')[0];
            } else {
                trimmedAttribute = untrimmedAttribute._substring(int(bytes(untrimmedAttribute).length - 1), 1);
            }
            
            PunkAttributeValue attrValue = PunkAttributeValue(uint(extendedPunkDataContract.attrStringToEnumMapping(trimmedAttribute)));
            PunkAttributeType attrType = PunkAttributeType(uint(extendedPunkDataContract.attrValueToTypeEnumMapping(ExtendedPunkDataInterface.PunkAttributeValue(uint(attrValue)))));
            
            if (attrType == PunkAttributeType.SEX) {
                punk.sex = attrValue;
            } else if (attrType == PunkAttributeType.HAIR) {
                punk.hair = attrValue;
            } else if (attrType == PunkAttributeType.EYES) {
                punk.eyes = attrValue;
            } else if (attrType == PunkAttributeType.BEARD) {
                punk.beard = attrValue;
            } else if (attrType == PunkAttributeType.EARS) {
                punk.ears = attrValue;
            } else if (attrType == PunkAttributeType.LIPS) {
                punk.lips = attrValue;
            } else if (attrType == PunkAttributeType.MOUTH) {
                punk.mouth = attrValue;
            } else if (attrType == PunkAttributeType.FACE) {
                punk.face = attrValue;
            } else if (attrType == PunkAttributeType.EMOTION) {
                punk.emotion = attrValue;
            } else if (attrType == PunkAttributeType.NECK) {
                punk.neck = attrValue;
            } else if (attrType == PunkAttributeType.NOSE) {
                punk.nose = attrValue;
            } else if (attrType == PunkAttributeType.CHEEKS) {
                punk.cheeks = attrValue;
            } else if (attrType == PunkAttributeType.TEETH) {
                punk.teeth = attrValue;
            }
        }
        
        return punk;
    }

    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    function tokenImage(uint16 tokenId) public view returns (string memory) {
        bytes memory pixels = punkDataContract.punkImage(uint16(tokenId));
        bytes memory svgBytes = DynamicBuffer.allocate(1024 * 128);
        
        svgBytes.appendSafe('<svg width="1200" height="1200" shape-rendering="crispEdges" xmlns="http://www.w3.org/2000/svg" version="1.2" viewBox="0 0 24 24"><style>rect{width:1px;height:1px}</style><rect x="0" y="0" style="width:100%;height:100%" fill="#ef821f" /><g style="transform: translate(calc(50% - 12px), calc(50% - 12px))">');
        
        bytes memory buffer = new bytes(8);
        for (uint256 y = 0; y < 24; y++) {
            for (uint256 x = 0; x < 24; x++) {
                uint256 p = (y * 24 + x) * 4;
                if (uint8(pixels[p + 3]) > 0) {
                    for (uint256 i = 0; i < 4; i++) {
                        uint8 value = uint8(pixels[p + i]);
                        
                        buffer[i * 2 + 1] = _HEX_SYMBOLS[value & 0xf];
                        value >>= 4;
                        buffer[i * 2] = _HEX_SYMBOLS[value & 0xf];
                    }

                    string memory oldColor = string(buffer);
                    
                    svgBytes.appendSafe(
                        abi.encodePacked(
                            '<rect x="',
                            x.toString(),
                            '" y="',
                            y.toString(),
                            '" fill="#',
                            oldColor,
                            '"/>'
                        )
                    );
                }
            }
        }
        
        svgBytes.appendSafe('</g></svg>');
        return string(svgBytes);
    }

    function punkAttributeCount(Punk memory punk) private pure returns (uint totalCount) {
        PunkAttributeValue[13] memory attrArray = [
            punk.sex,
            punk.hair,
            punk.eyes,
            punk.beard,
            punk.ears,
            punk.lips,
            punk.mouth,
            punk.face,
            punk.emotion,
            punk.neck,
            punk.nose,
            punk.cheeks,
            punk.teeth
        ];
        
        for (uint i = 0; i < 13; ++i) {
            if (attrArray[i] != PunkAttributeValue.NONE) {
                totalCount++;
            }
        }
        // Don't count sex as an attribute
        totalCount--;
    }

    function punkAttributesAsJSON(uint16 punkId) public view returns (string memory json) {
        Punk memory punk = initializePunk(punkId);
        PunkAttributeValue none = PunkAttributeValue.NONE;
        
        bytes memory output = "[";
        
        PunkAttributeValue[13] memory attrArray = [
            punk.sex,
            punk.hair,
            punk.eyes,
            punk.beard,
            punk.ears,
            punk.lips,
            punk.mouth,
            punk.face,
            punk.emotion,
            punk.neck,
            punk.nose,
            punk.cheeks,
            punk.teeth
        ];

        uint attrCount = punkAttributeCount(punk);
        uint count = 0;

        for (uint i = 0; i < 13; ++i) {
            PunkAttributeValue attrVal = attrArray[i];

            if (attrVal != none) {
                output = abi.encodePacked(output, punkAttributeAsJSON(attrVal));

                if (count < attrCount) {
                    output.appendSafe(",");
                    ++count;
                }
            }
        }
        
        return string(abi.encodePacked(output, "]"));
    }

    function punkAttributeAsJSON(PunkAttributeValue attribute) internal view returns (string memory json) {
        require(attribute != PunkAttributeValue.NONE);

        string memory attributeAsString = extendedPunkDataContract.attrEnumToStringMapping(ExtendedPunkDataInterface.PunkAttributeValue(uint(attribute)));
        string memory attributeTypeAsString;
        
        PunkAttributeType attrType = PunkAttributeType(uint(extendedPunkDataContract.attrValueToTypeEnumMapping(ExtendedPunkDataInterface.PunkAttributeValue(uint(attribute)))));

        if (attrType == PunkAttributeType.SEX) {
            attributeTypeAsString = "Sex";
        } else if (attrType == PunkAttributeType.HAIR) {
            attributeTypeAsString = "Hair";
        } else if (attrType == PunkAttributeType.EYES) {
            attributeTypeAsString = "Eyes";
        } else if (attrType == PunkAttributeType.BEARD) {
            attributeTypeAsString = "Beard";
        } else if (attrType == PunkAttributeType.EARS) {
            attributeTypeAsString = "Ears";
        } else if (attrType == PunkAttributeType.LIPS) {
            attributeTypeAsString = "Lips";
        } else if (attrType == PunkAttributeType.MOUTH) {
            attributeTypeAsString = "Mouth";
        } else if (attrType == PunkAttributeType.FACE) {
            attributeTypeAsString = "Face";
        } else if (attrType == PunkAttributeType.EMOTION) {
            attributeTypeAsString = "Emotion";
        } else if (attrType == PunkAttributeType.NECK) {
            attributeTypeAsString = "Neck";
        } else if (attrType == PunkAttributeType.NOSE) {
            attributeTypeAsString = "Nose";
        } else if (attrType == PunkAttributeType.CHEEKS) {
            attributeTypeAsString = "Cheeks";
        } else if (attrType == PunkAttributeType.TEETH) {
            attributeTypeAsString = "Teeth";
        }
        
        return string(abi.encodePacked('{"trait_type":"', attributeTypeAsString, '", "value":"', attributeAsString, '"}'));
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"punkDataContractAddress","type":"address"},{"internalType":"address","name":"extendedPunkDataContractAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"MintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"PunkMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PunksClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim_punks","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"deployer","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"uint256","name":"mintcount","type":"uint256"}],"name":"load_holder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicMintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"punkId","type":"uint16"}],"name":"punkAttributesAsJSON","outputs":[{"internalType":"string","name":"json","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"punkMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"set_reserve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"softReserve","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"count","type":"uint256"}],"name":"team_mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggle_PublicMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggle_PunkMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"tokenId","type":"uint16"}],"name":"tokenImage","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000086acf3ba5aea8d133d509bceedda5be6a6906ecb000000000000000000000000b87f4ae7df2fa784a90658b27ab13149ed26eb5d

-----Decoded View---------------
Arg [0] : punkDataContractAddress (address): 0x86Acf3BA5aEa8d133D509bceEdDa5Be6A6906ecb
Arg [1] : extendedPunkDataContractAddress (address): 0xB87f4ae7DF2Fa784A90658b27aB13149eD26eB5d

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000086acf3ba5aea8d133d509bceedda5be6a6906ecb
Arg [1] : 000000000000000000000000b87f4ae7df2fa784a90658b27ab13149ed26eb5d

78643:15787:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81321:38;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;81321:38:0;;;;;;;;61195:305;;;;;;;;;;-1:-1:-1;61195:305:0;;;;;:::i;:::-;;:::i;:::-;;;747:14:1;;740:22;722:41;;710:2;695:18;61195:305:0;582:187:1;91192:1172:0;;;;;;;;;;-1:-1:-1;91192:1172:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;62378:100::-;;;;;;;;;;;;;:::i;63939:221::-;;;;;;;;;;-1:-1:-1;63939:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2156:32:1;;;2138:51;;2126:2;2111:18;63939:221:0;1992:203:1;63461:412:0;;;;;;;;;;-1:-1:-1;63461:412:0;;;;;:::i;:::-;;:::i;:::-;;81464:42;;;;;;;;;;-1:-1:-1;81464:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;81223;;;;;;;;;;-1:-1:-1;81223:42:0;;;;;;;;61512:119;;;;;;;;;;;;;:::i;64689:339::-;;;;;;;;;;-1:-1:-1;64689:339:0;;;;;:::i;:::-;;:::i;83490:186::-;;;;;;;;;;;;;:::i;65099:185::-;;;;;;;;;;-1:-1:-1;65099:185:0;;;;;:::i;:::-;;:::i;84094:101::-;;;;;;;;;;-1:-1:-1;84094:101:0;;;;;:::i;:::-;;:::i;62072:239::-;;;;;;;;;;-1:-1:-1;62072:239:0;;;;;:::i;:::-;;:::i;61802:208::-;;;;;;;;;;-1:-1:-1;61802:208:0;;;;;:::i;:::-;;:::i;40518:103::-;;;;;;;;;;;;;:::i;83791:92::-;;;;;;;;;;-1:-1:-1;83791:92:0;;;;;:::i;:::-;;:::i;83268:106::-;;;;;;;;;;;;;:::i;39870:87::-;;;;;;;;;;-1:-1:-1;39943:6:0;;-1:-1:-1;;;;;39943:6:0;39870:87;;81513:42;;;;;;;;;;-1:-1:-1;81513:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;62547:104;;;;;;;;;;;;;:::i;88668:1797::-;;;;;;;;;;-1:-1:-1;88668:1797:0;;;;;:::i;:::-;;:::i;81272:42::-;;;;;;;;;;-1:-1:-1;81272:42:0;;;;;;;;;;;82602:656;;;:::i;83382:100::-;;;;;;;;;;;;;:::i;82066:528::-;;;;;;:::i;:::-;;:::i;64232:155::-;;;;;;;;;;-1:-1:-1;64232:155:0;;;;;:::i;:::-;;:::i;83684:99::-;;;;;;;;;;-1:-1:-1;83684:99:0;;;;;:::i;:::-;;:::i;65355:328::-;;;;;;;;;;-1:-1:-1;65355:328:0;;;;;:::i;:::-;;:::i;81366:41::-;;;;;;;;;;;;;;;;84203:185;;;;;;;;;;-1:-1:-1;84203:185:0;;;;;:::i;:::-;;:::i;83893:158::-;;;;;;;;;;-1:-1:-1;83893:158:0;;;;;:::i;:::-;;:::i;61643:95::-;;;;;;;;;;-1:-1:-1;61720:10:0;61643:95;;81426:31;;;;;;;;;;-1:-1:-1;81426:31:0;;;;-1:-1:-1;;;;;81426:31:0;;;81168:48;;;;;;;;;;;;;;;;64458:164;;;;;;;;;;-1:-1:-1;64458:164:0;;;;;:::i;:::-;;:::i;40776:201::-;;;;;;;;;;-1:-1:-1;40776:201:0;;;;;:::i;:::-;;:::i;61195:305::-;61297:4;-1:-1:-1;;;;;;61334:40:0;;-1:-1:-1;;;61334:40:0;;:105;;-1:-1:-1;;;;;;;61391:48:0;;-1:-1:-1;;;61391:48:0;61334:105;:158;;;-1:-1:-1;;;;;;;;;;53708:40:0;;;61456:36;61314:178;61195:305;-1:-1:-1;;61195:305:0:o;91192:1172::-;91258:18;91289:16;91308:22;91323:6;91308:14;:22::i;:::-;91289:41;;91341:23;91411:19;:25;;;;;;;;;;;;;-1:-1:-1;;;91411:25:0;;;;;91457:39;:372;;;;;;;;91514:4;:8;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91537:4;:9;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91561:4;:9;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91585:4;:10;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91610:4;:9;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91634:4;:9;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91658:4;:10;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91683:4;:9;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91707:4;:12;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91734:4;:9;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91758:4;:9;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91782:4;:11;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91808:4;:10;;;91457:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;-1:-1:-1;91842:14:0;91859:24;91878:4;91859:18;:24::i;:::-;91842:41;;91894:10;91926:6;91921:371;91942:2;91938:1;:6;91921:371;;;91966:26;91995:9;92005:1;91995:12;;;;;;;:::i;:::-;;;;;91966:41;;92039:4;92028:15;;;;;;;;:::i;:::-;:7;:15;;;;;;;;:::i;:::-;;92024:257;;92090:6;92098:28;92118:7;92098:19;:28::i;:::-;92073:54;;;;;;;;;:::i;:::-;;;;;;;;;;;;;92064:63;;92160:9;92152:5;:17;92148:118;;;92194:22;;;;;;;;;;;;-1:-1:-1;;;92194:22:0;;;;;;:6;;:17;:22::i;:::-;92239:7;;;:::i;:::-;;;92148:118;-1:-1:-1;91946:3:0;;;:::i;:::-;;;91921:371;;;;92343:6;92326:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;92312:44;;;;;;;;91192:1172;;;:::o;62378:100::-;62432:13;62465:5;62458:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62378:100;:::o;63939:221::-;64015:7;67282:16;;;:7;:16;;;;;;-1:-1:-1;;;;;67282:16:0;64035:73;;;;-1:-1:-1;;;64035:73:0;;7777:2:1;64035:73:0;;;7759:21:1;7816:2;7796:18;;;7789:30;7855:34;7835:18;;;7828:62;-1:-1:-1;;;7906:18:1;;;7899:42;7958:19;;64035:73:0;;;;;;;;;-1:-1:-1;64128:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;64128:24:0;;63939:221::o;63461:412::-;63542:13;63558:24;63574:7;63558:15;:24::i;:::-;63542:40;;63607:5;-1:-1:-1;;;;;63601:11:0;:2;-1:-1:-1;;;;;63601:11:0;;63593:57;;;;-1:-1:-1;;;63593:57:0;;8190:2:1;63593:57:0;;;8172:21:1;8229:2;8209:18;;;8202:30;8268:34;8248:18;;;8241:62;-1:-1:-1;;;8319:18:1;;;8312:31;8360:19;;63593:57:0;7988:397:1;63593:57:0;38501:10;-1:-1:-1;;;;;63685:21:0;;;;:62;;-1:-1:-1;63710:37:0;63727:5;38501:10;64458:164;:::i;63710:37::-;63663:168;;;;-1:-1:-1;;;63663:168:0;;8592:2:1;63663:168:0;;;8574:21:1;8631:2;8611:18;;;8604:30;8670:34;8650:18;;;8643:62;8741:26;8721:18;;;8714:54;8785:19;;63663:168:0;8390:420:1;63663:168:0;63844:21;63853:2;63857:7;63844:8;:21::i;:::-;63531:342;63461:412;;:::o;61512:119::-;61564:7;61604:19;;61591:10;:32;;;;:::i;:::-;61584:39;;61512:119;:::o;64689:339::-;64884:41;38501:10;64917:7;64884:18;:41::i;:::-;64876:103;;;;-1:-1:-1;;;64876:103:0;;;;;;;:::i;:::-;64992:28;65002:4;65008:2;65012:7;64992:9;:28::i;83490:186::-;39756:13;:11;:13::i;:::-;21942:21:::1;:19;:21::i;:::-;83572:49:::2;::::0;83554:12:::2;::::0;83572:10:::2;::::0;83595:21:::2;::::0;83554:12;83572:49;83554:12;83572:49;83595:21;83572:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83553:68;;;83640:7;83632:36;;;::::0;-1:-1:-1;;;83632:36:0;;9778:2:1;83632:36:0::2;::::0;::::2;9760:21:1::0;9817:2;9797:18;;;9790:30;-1:-1:-1;;;9836:18:1;;;9829:46;9892:18;;83632:36:0::2;9576:340:1::0;83632:36:0::2;83542:134;21986:20:::1;21380:1:::0;22506:7;:22;22323:213;21986:20:::1;83490:186::o:0;65099:185::-;65237:39;65254:4;65260:2;65264:7;65237:39;;;;;;;;;;;;:16;:39::i;84094:101::-;84147:4;67282:16;;;:7;:16;;;;;;-1:-1:-1;;;;;67282:16:0;:30;;84171:16;67193:127;62072:239;62144:7;62180:16;;;:7;:16;;;;;;-1:-1:-1;;;;;62180:16:0;;62207:73;;;;-1:-1:-1;;;62207:73:0;;10123:2:1;62207:73:0;;;10105:21:1;10162:2;10142:18;;;10135:30;10201:34;10181:18;;;10174:62;-1:-1:-1;;;10252:18:1;;;10245:39;10301:19;;62207:73:0;9921:405:1;61802:208:0;61874:7;-1:-1:-1;;;;;61902:19:0;;61894:74;;;;-1:-1:-1;;;61894:74:0;;10533:2:1;61894:74:0;;;10515:21:1;10572:2;10552:18;;;10545:30;10611:34;10591:18;;;10584:62;-1:-1:-1;;;10662:18:1;;;10655:40;10712:19;;61894:74:0;10331:406:1;61894:74:0;-1:-1:-1;;;;;;61986:16:0;;;;;:9;:16;;;;;;;61802:208::o;40518:103::-;39756:13;:11;:13::i;:::-;40583:30:::1;40610:1;40583:18;:30::i;83791:92::-:0;39756:13;:11;:13::i;:::-;83855:11:::1;:20:::0;83791:92::o;83268:106::-;39756:13;:11;:13::i;:::-;83349:17:::1;::::0;;-1:-1:-1;;83328:38:0;::::1;83349:17;::::0;;::::1;83348:18;83328:38;::::0;;83268:106::o;62547:104::-;62603:13;62636:7;62629:14;;;;;:::i;88668:1797::-;88773:43;;-1:-1:-1;;;88773:43:0;;10916:6:1;10904:19;;88773:43:0;;;10886:38:1;88725:13:0;;88751:19;;-1:-1:-1;;;;;88773:16:0;:26;;;;10859:18:1;;88773:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;88773:43:0;;;;;;;;;;;;:::i;:::-;16834:4;16828:11;;17147:20;;;17185:25;;;17323:19;17360:25;;88827:21;17515:4;17500:20;;;17579:17;;;88751:65;;-1:-1:-1;88827:58:0;88906:328;;;;;;;;;;;;;;;;;;:8;;:19;:328::i;:::-;89277:12;;;89287:1;89277:12;;;;;;;;;89255:19;;89277:12;;;;;;;;;;-1:-1:-1;89277:12:0;89255:34;;89305:9;89300:1070;89324:2;89320:1;:6;89300:1070;;;89353:9;89348:1011;89372:2;89368:1;:6;89348:1011;;;89400:9;89422:1;89413:6;:1;89417:2;89413:6;:::i;:::-;:10;;;;:::i;:::-;89412:16;;89427:1;89412:16;:::i;:::-;89400:28;-1:-1:-1;89474:1:0;89457:6;89464:5;89400:28;89468:1;89464:5;:::i;:::-;89457:13;;;;;;;;:::i;:::-;;;;;;;89451:24;89447:897;;;89505:9;89500:321;89524:1;89520;:5;89500:321;;;89559:11;89579:6;89586:5;89590:1;89586;:5;:::i;:::-;89579:13;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;;;;89687:3:0;89679:11;;89666:25;;;;;;;:::i;:::-;;;;89646:6;89653:5;:1;89657;89653:5;:::i;:::-;:9;;89661:1;89653:9;:::i;:::-;89646:17;;;;;;;;:::i;:::-;;;;:45;-1:-1:-1;;;;;89646:45:0;;;;;;;;-1:-1:-1;89728:1:0;89718:11;;;-1:-1:-1;;;89718:11:0;89772:25;;;;;;;:::i;:::-;;;;89756:6;89763:5;:1;89767;89763:5;:::i;:::-;89756:13;;;;;;;;:::i;:::-;;;;:41;-1:-1:-1;;;;;89756:41:0;;;;;;;;;89532:289;89527:3;;;;;:::i;:::-;;;;89500:321;;;-1:-1:-1;89877:6:0;89929:395;90064:12;:1;:10;:12::i;:::-;90145;:1;:10;:12::i;:::-;90230:8;89975:326;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;89975:326:0;;;;;;;;;89929:8;;:19;:395::i;:::-;89477:867;89447:897;-1:-1:-1;89376:3:0;;;;:::i;:::-;;;;89348:1011;;;-1:-1:-1;89328:3:0;;;;:::i;:::-;;;;89300:1070;;;-1:-1:-1;90390:33:0;;;;;;;;;;;;-1:-1:-1;;;90390:33:0;;;;;;:8;;:19;:33::i;:::-;-1:-1:-1;90448:8:0;88668:1797;-1:-1:-1;;;88668:1797:0:o;82602:656::-;82661:15;;;;;;;82653:46;;;;-1:-1:-1;;;82653:46:0;;13587:2:1;82653:46:0;;;13569:21:1;13626:2;13606:18;;;13599:30;-1:-1:-1;;;13645:18:1;;;13638:48;13703:18;;82653:46:0;13385:342:1;82653:46:0;82729:10;82718:22;;;;:10;:22;;;;;;;;:30;;:22;:30;82710:68;;;;-1:-1:-1;;;82710:68:0;;13934:2:1;82710:68:0;;;13916:21:1;13973:2;13953:18;;;13946:30;14012:27;13992:18;;;13985:55;14057:18;;82710:68:0;13732:349:1;82710:68:0;82810:15;;82797:9;:28;82789:73;;;;-1:-1:-1;;;82789:73:0;;14288:2:1;82789:73:0;;;14270:21:1;;;14307:18;;;14300:30;14366:34;14346:18;;;14339:62;14418:18;;82789:73:0;14086:356:1;82789:73:0;82899:10;82875;82888:22;;;:10;:22;;;;;;:26;;82913:1;82888:26;:::i;:::-;82875:39;-1:-1:-1;82933:10:0;82947:9;82933:23;82925:66;;;;-1:-1:-1;;;82925:66:0;;14649:2:1;82925:66:0;;;14631:21:1;14688:2;14668:18;;;14661:30;14727:32;14707:18;;;14700:60;14777:18;;82925:66:0;14447:354:1;82925:66:0;61720:10;83026:5;83010:13;:11;:13::i;:::-;:21;;;;:::i;:::-;:36;;83002:58;;;;-1:-1:-1;;;83002:58:0;;15008:2:1;83002:58:0;;;14990:21:1;15047:1;15027:18;;;15020:29;-1:-1:-1;;;15065:18:1;;;15058:39;15114:18;;83002:58:0;14806:332:1;83002:58:0;83116:10;83130:5;83105:22;;;:10;:22;;;;;:30;;-1:-1:-1;;83105:30:0;;;83161:12;;:20;;83176:5;;83161:20;:::i;:::-;83146:12;:35;83218:30;83230:10;83242:5;83218:11;:30::i;:::-;82640:618;82602:656::o;83382:100::-;39756:13;:11;:13::i;:::-;83459:15:::1;::::0;;-1:-1:-1;;83440:34:0;::::1;83459:15;::::0;;;::::1;;;83458:16;83440:34:::0;;::::1;;::::0;;83382:100::o;82066:528::-;82140:17;;;;82132:48;;;;-1:-1:-1;;;82132:48:0;;13587:2:1;82132:48:0;;;13569:21:1;13626:2;13606:18;;;13599:30;-1:-1:-1;;;13645:18:1;;;13638:48;13703:18;;82132:48:0;13385:342:1;82132:48:0;82208:15;;82255:12;82208:15;82255:5;:12;:::i;:::-;82242:9;:25;;82234:70;;;;-1:-1:-1;;;82234:70:0;;14288:2:1;82234:70:0;;;14270:21:1;;;14307:18;;;14300:30;14366:34;14346:18;;;14339:62;14418:18;;82234:70:0;14086:356:1;82234:70:0;61720:10;82341:5;82325:13;:11;:13::i;:::-;:21;;;;:::i;:::-;:36;;82317:58;;;;-1:-1:-1;;;82317:58:0;;15008:2:1;82317:58:0;;;14990:21:1;15047:1;15027:18;;;15020:29;-1:-1:-1;;;15065:18:1;;;15058:39;15114:18;;82317:58:0;14806:332:1;82317:58:0;82419:11;;82410:5;82394:13;:11;:13::i;:::-;:21;;;;:::i;:::-;:36;;82386:76;;;;-1:-1:-1;;;82386:76:0;;15345:2:1;82386:76:0;;;15327:21:1;15384:2;15364:18;;;15357:30;15423:29;15403:18;;;15396:57;15470:18;;82386:76:0;15143:351:1;82386:76:0;82483:10;82497:9;82483:23;82475:66;;;;-1:-1:-1;;;82475:66:0;;14649:2:1;82475:66:0;;;14631:21:1;14688:2;14668:18;;;14661:30;14727:32;14707:18;;;14700:60;14777:18;;82475:66:0;14447:354:1;82475:66:0;82554:30;82566:10;82578:5;82554:11;:30::i;:::-;82111:483;82066:528;:::o;64232:155::-;64327:52;38501:10;64360:8;64370;64327:18;:52::i;83684:99::-;39756:13;:11;:13::i;:::-;83745:30:::1;83757:10;83769:5;83745:11;:30::i;65355:328::-:0;65530:41;38501:10;65563:7;65530:18;:41::i;:::-;65522:103;;;;-1:-1:-1;;;65522:103:0;;;;;;;:::i;:::-;65636:39;65650:4;65656:2;65660:7;65669:5;65636:13;:39::i;:::-;65355:328;;;;:::o;84203:185::-;67258:4;67282:16;;;:7;:16;;;;;;84263:13;;-1:-1:-1;;;;;67282:16:0;84289:44;;;;-1:-1:-1;;;84289:44:0;;15701:2:1;84289:44:0;;;15683:21:1;15740:2;15720:18;;;15713:30;-1:-1:-1;;;15759:18:1;;;15752:50;15819:18;;84289:44:0;15499:344:1;84289:44:0;84351:29;84376:2;84351:17;:29::i;83893:158::-;81620:8;;-1:-1:-1;;;;;81620:8:0;81607:9;:21;81599:48;;;;-1:-1:-1;;;81599:48:0;;16050:2:1;81599:48:0;;;16032:21:1;16089:2;16069:18;;;16062:30;-1:-1:-1;;;16108:18:1;;;16101:44;16162:18;;81599:48:0;15848:338:1;81599:48:0;-1:-1:-1;;;;;83977:18:0;;::::1;;::::0;;;:10:::1;:18;::::0;;;;;;;:25;;-1:-1:-1;;83977:25:0::1;83998:4;83977:25;::::0;;84013:10:::1;:18:::0;;;;;:30;83893:158::o;64458:164::-;-1:-1:-1;;;;;64579:25:0;;;64555:4;64579:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;64458:164::o;40776:201::-;39756:13;:11;:13::i;:::-;-1:-1:-1;;;;;40865:22:0;::::1;40857:73;;;::::0;-1:-1:-1;;;40857:73:0;;16393:2:1;40857:73:0::1;::::0;::::1;16375:21:1::0;16432:2;16412:18;;;16405:30;16471:34;16451:18;;;16444:62;-1:-1:-1;;;16522:18:1;;;16515:36;16568:19;;40857:73:0::1;16191:402:1::0;40857:73:0::1;40941:28;40960:8;40941:18;:28::i;85486:3107::-:0;85547:11;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85547:11:0;85590:621;;;;;;;;;;;;;;85571:16;;85590:621;;;85571:16;85590:621;;;;85684:23;85590:621;;;;85728:23;85590:621;;;;85773:23;85590:621;;;;85817:23;85590:621;;;;85861:23;85590:621;;;;85906:23;85590:621;;;;85950:23;85590:621;;;;85997:23;85590:621;;;;86041:23;85590:621;;;;86085:23;85590:621;;;;86131:23;85590:621;;;;86176:23;85590:621;;86232:16;;;;;;86296:40;;-1:-1:-1;;;86296:40:0;;;;;10886:38:1;;;;86232:16:0;;-1:-1:-1;86232:7:0;;86296:16;-1:-1:-1;;;;;86296:31:0;;;;10859:18:1;;86296:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;86296:40:0;;;;;;;;;;;;:::i;:::-;86269:67;;86349:30;86382:21;;;;;;;;;;;;;;-1:-1:-1;;;86382:21:0;;;:10;:16;;:21;;;;:::i;:::-;86349:54;;86429:6;86424:2130;86445:14;:21;86441:1;:25;86424:2130;;;86488:32;86523:14;86538:1;86523:17;;;;;;;;:::i;:::-;;;;;;;86488:52;;86555:30;86622:1;86618;:5;86614:232;;;86663:29;;;;;;;;;;;;-1:-1:-1;;;86663:29:0;;;;;;:18;;:24;:29::i;:::-;86693:1;86663:32;;;;;;;;:::i;:::-;;;;;;;86644:51;;86614:232;;;86755:75;86824:1;86795:18;86789:32;:36;;;;:::i;:::-;86755:18;;86828:1;86755:29;:75::i;:::-;86736:94;;86614:232;86929:66;;-1:-1:-1;;;86929:66:0;;86874:28;;-1:-1:-1;;;;;86929:24:0;:48;;;;:66;;86978:16;;86929:66;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;86924:72;;;;;;;;:::i;:::-;86905:92;;;;;;;;:::i;:::-;86874:123;;87012:26;87064:24;-1:-1:-1;;;;;87064:51:0;;87166:9;87161:15;;;;;;;;:::i;:::-;87116:61;;;;;;;;:::i;:::-;87064:114;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;87059:120;;;;;;;;:::i;:::-;87041:139;;;;;;;;:::i;:::-;87012:168;-1:-1:-1;87225:21:0;87213:8;:33;;;;;;;;:::i;:::-;;87209:1334;;87267:8;;;87278:9;87267:20;;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;87209:1334:0;;;87325:22;87313:8;:34;;;;;;;;:::i;:::-;;87309:1234;;87368:9;;;87380;87368:21;;;;;;;;:::i;87309:1234::-;87427:22;87415:8;:34;;;;;;;;:::i;:::-;;87411:1132;;87470:9;;;87482;87470:21;;;;;;;;:::i;87411:1132::-;87529:23;87517:8;:35;;;;;;;;:::i;:::-;;87513:1030;;87573:10;;;87586:9;87573:22;;;;;;;;:::i;87513:1030::-;87633:22;87621:8;:34;;;;;;;;:::i;:::-;;87617:926;;87676:9;;;87688;87676:21;;;;;;;;:::i;87617:926::-;87735:22;87723:8;:34;;;;;;;;:::i;:::-;;87719:824;;87778:9;;;87790;87778:21;;;;;;;;:::i;87719:824::-;87837:23;87825:8;:35;;;;;;;;:::i;:::-;;87821:722;;87881:10;;;87894:9;87881:22;;;;;;;;:::i;87821:722::-;87941:22;87929:8;:34;;;;;;;;:::i;:::-;;87925:618;;87984:9;;;87996;87984:21;;;;;;;;:::i;87925:618::-;88043:25;88031:8;:37;;;;;;;;:::i;:::-;;88027:516;;88089:12;;;88104:9;88089:24;;;;;;;;:::i;88027:516::-;88151:22;88139:8;:34;;;;;;;;:::i;:::-;;88135:408;;88194:9;;;88206;88194:21;;;;;;;;:::i;88135:408::-;88253:22;88241:8;:34;;;;;;;;:::i;:::-;;88237:306;;88296:9;;;88308;88296:21;;;;;;;;:::i;88237:306::-;88355:24;88343:8;:36;;;;;;;;:::i;:::-;;88339:204;;88400:11;;;88414:9;88400:23;;;;;;;;:::i;88339:204::-;88461:23;88449:8;:35;;;;;;;;:::i;:::-;;88445:98;;88505:10;;;88518:9;88505:22;;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;88445:98:0;86473:2081;;;;86468:3;;;;;:::i;:::-;;;;86424:2130;;;-1:-1:-1;88581:4:0;;85486:3107;-1:-1:-1;;;;85486:3107:0:o;90473:711::-;90541:15;90569:39;:372;;;;;;;;90626:4;:8;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90649:4;:9;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90673:4;:9;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90697:4;:10;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90722:4;:9;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90746:4;:9;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90770:4;:10;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90795:4;:9;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90819:4;:12;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90846:4;:9;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90870:4;:9;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90894:4;:11;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90920:4;:10;;;90569:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;-1:-1:-1;90967:6:0;90962:148;90983:2;90979:1;:6;90962:148;;;91027:23;91011:9;91021:1;91011:12;;;;;;;:::i;:::-;;;;;:39;;;;;;;;:::i;:::-;;91007:92;;91071:12;;;;:::i;:::-;;;;91007:92;90987:3;;;:::i;:::-;;;90962:148;;;-1:-1:-1;91164:12:0;;;;:::i;:::-;;90473:711;-1:-1:-1;;;;90473:711:0:o;92372:2053::-;92454:18;92506:23;92493:9;:36;;;;;;;;:::i;:::-;;92485:45;;;;;;92543:31;92577:24;-1:-1:-1;;;;;92577:48:0;;92676:9;92671:15;;;;;;;;:::i;:::-;92626:61;;;;;;;;:::i;:::-;92577:111;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;92577:111:0;;;;;;;;;;;;:::i;:::-;92543:145;;92699:35;92755:26;92807:24;-1:-1:-1;;;;;92807:51:0;;92909:9;92904:15;;;;;;;;:::i;:::-;92859:61;;;;;;;;:::i;:::-;92807:114;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;92802:120;;;;;;;;:::i;:::-;92784:139;;;;;;;;:::i;:::-;92755:168;-1:-1:-1;92952:21:0;92940:8;:33;;;;;;;;:::i;:::-;;92936:1347;;92990:29;;;;;;;;;;;;;-1:-1:-1;;;92990:29:0;;;;;92936:1347;;;93053:22;93041:8;:34;;;;;;;;:::i;:::-;;93037:1246;;93092:30;;;;;;;;;;;;;-1:-1:-1;;;93092:30:0;;;;;93037:1246;;;93156:22;93144:8;:34;;;;;;;;:::i;:::-;;93140:1143;;93195:30;;;;;;;;;;;;;-1:-1:-1;;;93195:30:0;;;;;93140:1143;;;93259:23;93247:8;:35;;;;;;;;:::i;:::-;;93243:1040;;93299:31;;;;;;;;;;;;;-1:-1:-1;;;93299:31:0;;;;;93243:1040;;;93364:22;93352:8;:34;;;;;;;;:::i;:::-;;93348:935;;93403:30;;;;;;;;;;;;;-1:-1:-1;;;93403:30:0;;;;;93348:935;;;93467:22;93455:8;:34;;;;;;;;:::i;:::-;;93451:832;;93506:30;;;;;;;;;;;;;-1:-1:-1;;;93506:30:0;;;;;93451:832;;;93570:23;93558:8;:35;;;;;;;;:::i;:::-;;93554:729;;93610:31;;;;;;;;;;;;;-1:-1:-1;;;93610:31:0;;;;;93554:729;;;93675:22;93663:8;:34;;;;;;;;:::i;:::-;;93659:624;;93714:30;;;;;;;;;;;;;-1:-1:-1;;;93714:30:0;;;;;93659:624;;;93778:25;93766:8;:37;;;;;;;;:::i;:::-;;93762:521;;93820:33;;;;;;;;;;;;;-1:-1:-1;;;93820:33:0;;;;;93762:521;;;93887:22;93875:8;:34;;;;;;;;:::i;:::-;;93871:412;;93926:30;;;;;;;;;;;;;-1:-1:-1;;;93926:30:0;;;;;93871:412;;;93990:22;93978:8;:34;;;;;;;;:::i;:::-;;93974:309;;94029:30;;;;;;;;;;;;;-1:-1:-1;;;94029:30:0;;;;;93974:309;;;94093:24;94081:8;:36;;;;;;;;:::i;:::-;;94077:206;;94134:32;;;;;;;;;;;;;-1:-1:-1;;;94134:32:0;;;;;94077:206;;;94200:23;94188:8;:35;;;;;;;;:::i;:::-;;94184:99;;94240:31;;;;;;;;;;;;;-1:-1:-1;;;94240:31:0;;;;;94184:99;94353:21;94392:17;94317:99;;;;;;;;;:::i;:::-;;;;;;;;;;;;;94303:114;;;;;92372:2053;;;:::o;19155:437::-;-1:-1:-1;;19338:17:0;;19332:24;19387:13;;19454:11;;-1:-1:-1;;19328:35:0;;;;;;19445:20;;19387:13;19445:20;:::i;:::-;:32;;19423:121;;;;-1:-1:-1;;;19423:121:0;;19355:2:1;19423:121:0;;;19337:21:1;19394:2;19374:18;;;19367:30;19433:34;19413:18;;;19406:62;-1:-1:-1;;;19484:18:1;;;19477:37;19531:19;;19423:121:0;19153:403:1;19423:121:0;19555:29;19571:6;19579:4;19555:15;:29::i;73261:175::-;73336:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;73336:29:0;-1:-1:-1;;;;;73336:29:0;;;;;;;;:24;;73390;73336;73390:15;:24::i;:::-;-1:-1:-1;;;;;73381:47:0;;;;;;;;;;;73261:175;;:::o;67487:349::-;67580:4;67282:16;;;:7;:16;;;;;;-1:-1:-1;;;;;67282:16:0;67597:73;;;;-1:-1:-1;;;67597:73:0;;19763:2:1;67597:73:0;;;19745:21:1;19802:2;19782:18;;;19775:30;19841:34;19821:18;;;19814:62;-1:-1:-1;;;19892:18:1;;;19885:42;19944:19;;67597:73:0;19561:408:1;67597:73:0;67681:13;67697:24;67713:7;67697:15;:24::i;:::-;67681:40;;67751:5;-1:-1:-1;;;;;67740:16:0;:7;-1:-1:-1;;;;;67740:16:0;;:51;;;;67784:7;-1:-1:-1;;;;;67760:31:0;:20;67772:7;67760:11;:20::i;:::-;-1:-1:-1;;;;;67760:31:0;;67740:51;:87;;;;67795:32;67812:5;67819:7;67795:16;:32::i;72517:626::-;72677:4;-1:-1:-1;;;;;72649:32:0;:24;72665:7;72649:15;:24::i;:::-;-1:-1:-1;;;;;72649:32:0;;72641:82;;;;-1:-1:-1;;;72641:82:0;;20176:2:1;72641:82:0;;;20158:21:1;20215:2;20195:18;;;20188:30;20254:34;20234:18;;;20227:62;-1:-1:-1;;;20305:18:1;;;20298:35;20350:19;;72641:82:0;19974:401:1;72641:82:0;-1:-1:-1;;;;;72742:16:0;;72734:65;;;;-1:-1:-1;;;72734:65:0;;20582:2:1;72734:65:0;;;20564:21:1;20621:2;20601:18;;;20594:30;20660:34;20640:18;;;20633:62;-1:-1:-1;;;20711:18:1;;;20704:34;20755:19;;72734:65:0;20380:400:1;72734:65:0;72916:29;72933:1;72937:7;72916:8;:29::i;:::-;-1:-1:-1;;;;;72958:15:0;;;;;;:9;:15;;;;;:20;;72977:1;;72958:15;:20;;72977:1;;72958:20;:::i;:::-;;;;-1:-1:-1;;;;;;;72989:13:0;;;;;;:9;:13;;;;;:18;;73006:1;;72989:13;:18;;73006:1;;72989:18;:::i;:::-;;;;-1:-1:-1;;73018:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;73018:21:0;-1:-1:-1;;;;;73018:21:0;;;;;;;;;73057:27;;73018:16;;73057:27;;;;;;;63531:342;63461:412;;:::o;40035:132::-;39943:6;;-1:-1:-1;;;;;39943:6:0;38501:10;40099:23;40091:68;;;;-1:-1:-1;;;40091:68:0;;20987:2:1;40091:68:0;;;20969:21:1;;;21006:18;;;20999:30;21065:34;21045:18;;;21038:62;21117:18;;40091:68:0;20785:356:1;22022:293:0;21424:1;22156:7;;:19;22148:63;;;;-1:-1:-1;;;22148:63:0;;21348:2:1;22148:63:0;;;21330:21:1;21387:2;21367:18;;;21360:30;21426:33;21406:18;;;21399:61;21477:18;;22148:63:0;21146:355:1;22148:63:0;21424:1;22289:7;:18;22022:293::o;41137:191::-;41230:6;;;-1:-1:-1;;;;;41247:17:0;;;-1:-1:-1;;;;;;41247:17:0;;;;;;;41280:40;;41230:6;;;41247:17;41230:6;;41280:40;;41211:16;;41280:40;41200:128;41137:191;:::o;35848:716::-;35904:13;35955:14;35972:17;35983:5;35972:10;:17::i;:::-;35992:1;35972:21;35955:38;;36008:20;36042:6;36031:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36031:18:0;-1:-1:-1;36008:41:0;-1:-1:-1;36173:28:0;;;36189:2;36173:28;36230:288;-1:-1:-1;;36262:5:0;-1:-1:-1;;;36399:2:0;36388:14;;36383:30;36262:5;36370:44;36460:2;36451:11;;;-1:-1:-1;36481:21:0;;36497:5;36481:21;36230:288;;68156:984;38501:10;68258:9;68242:25;68234:59;;;;-1:-1:-1;;;68234:59:0;;21840:2:1;68234:59:0;;;21822:21:1;21879:2;21859:18;;;21852:30;-1:-1:-1;;;21898:18:1;;;21891:51;21959:18;;68234:59:0;21638:345:1;68234:59:0;-1:-1:-1;;;;;68312:16:0;;68304:61;;;;-1:-1:-1;;;68304:61:0;;22190:2:1;68304:61:0;;;22172:21:1;;;22209:18;;;22202:30;22268:34;22248:18;;;22241:62;22320:18;;68304:61:0;21988:356:1;68304:61:0;68397:1;68384:10;:14;68376:67;;;;-1:-1:-1;;;68376:67:0;;22551:2:1;68376:67:0;;;22533:21:1;22590:2;22570:18;;;22563:30;22629:34;22609:18;;;22602:62;-1:-1:-1;;;22680:18:1;;;22673:38;22728:19;;68376:67:0;22349:404:1;68376:67:0;68597:10;68574:19;;:33;;68566:89;;;;-1:-1:-1;;;68566:89:0;;22960:2:1;68566:89:0;;;22942:21:1;22999:2;22979:18;;;22972:30;23038:34;23018:18;;;23011:62;-1:-1:-1;;;23089:18:1;;;23082:41;23140:19;;68566:89:0;22758:407:1;68566:89:0;68709:19;;68676:30;68739:288;68759:10;68755:1;:14;68739:288;;;68816:15;68834:56;68860:2;68864:25;68834;:56::i;:::-;68816:74;;68919:40;68947:2;68951:7;68919:27;:40::i;:::-;68988:27;;;:::i;:::-;;;68776:251;68771:3;;;;:::i;:::-;;;68739:288;;;-1:-1:-1;69047:19:0;:47;;;-1:-1:-1;;;;;69105:13:0;;;;;;:9;:13;;;;;:27;;69122:10;;69105:13;:27;;69122:10;;69105:27;:::i;:::-;;;;-1:-1:-1;;;;;68156:984:0:o;73578:315::-;73733:8;-1:-1:-1;;;;;73724:17:0;:5;-1:-1:-1;;;;;73724:17:0;;73716:55;;;;-1:-1:-1;;;73716:55:0;;23372:2:1;73716:55:0;;;23354:21:1;23411:2;23391:18;;;23384:30;23450:27;23430:18;;;23423:55;23495:18;;73716:55:0;23170:349:1;73716:55:0;-1:-1:-1;;;;;73782:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;73782:46:0;;;;;;;;;;73844:41;;722::1;;;73844::0;;695:18:1;73844:41:0;;;;;;;73578:315;;;:::o;66565:::-;66722:28;66732:4;66738:2;66742:7;66722:9;:28::i;:::-;66769:48;66792:4;66798:2;66802:7;66811:5;66769:22;:48::i;:::-;66761:111;;;;-1:-1:-1;;;66761:111:0;;;;;;;:::i;84396:1082::-;84461:13;84487:16;84512:19;84523:7;84512:10;:19::i;:::-;84487:45;;84543:18;84595;:7;:16;;;:18::i;:::-;84564:50;;;;;;;;:::i;:::-;;;;-1:-1:-1;;84564:50:0;;;;;;85014:16;;;;;;;;;;84564:50;;-1:-1:-1;84773:663:0;;84564:50;;85014:16;84564:50;85014:16;;;85178:18;85192:3;85178:13;:18::i;:::-;85287:29;85308:7;85287:20;:29::i;:::-;84849:537;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;84773:13;:663::i;:::-;84680:775;;;;;;;;:::i;:::-;;;;;;;;;;;;;84635:835;;;;84396:1082;;;:::o;9621:1267::-;9729:24;9798:5;9766:23;9864:1;9876:280;9913:1;9893:10;:17;:21;;;;:::i;:::-;9883:7;:31;9876:280;;;9931:10;9944:32;9953:5;9960:6;9968:7;9944:8;:32::i;:::-;9931:45;-1:-1:-1;9995:12:0;;9991:154;;10026:5;;;9991:154;10070:14;;;;:::i;:::-;;-1:-1:-1;10113:16:0;;-1:-1:-1;10118:6:0;10128:1;10113:16;:::i;:::-;10103:26;;9916:240;9876:280;;;10192:12;10179:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10168:37;;10228:1;10218:11;;10255:1;10240:16;;10267:588;10304:1;10284:10;:17;:21;;;;:::i;:::-;10274:7;:31;10267:588;;;10324:10;10337:32;10346:5;10353:6;10361:7;10337:8;:32::i;:::-;10324:45;-1:-1:-1;10388:13:0;;10384:85;;-1:-1:-1;10435:17:0;;10384:85;10485:18;10517:22;10532:7;10522:6;10517:22;:::i;:::-;10506:34;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;10506:34:0;-1:-1:-1;10485:55:0;-1:-1:-1;10485:55:0;10555:22;10647:7;10633:111;10665:6;10656:1;:16;10633:111;;;10715:10;10726:1;10715:13;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;10715:13:0;10698:9;10708:3;;;;:::i;:::-;;;10698:14;;;;;;;;:::i;:::-;;;;:30;-1:-1:-1;;;;;10698:30:0;;;;;;;;-1:-1:-1;10674:3:0;;;;:::i;:::-;;;;10633:111;;;-1:-1:-1;10768:16:0;10773:6;10783:1;10768:16;:::i;:::-;10758:26;-1:-1:-1;10833:9:0;10799:8;10808:14;;;;:::i;:::-;;;10799:24;;;;;;;;:::i;:::-;;;;;;:44;;;;10307:548;;;;10267:588;;;10865:15;;;9621:1267;;;;:::o;9061:550::-;9289:17;;9178:13;;9236:5;;9267:17;9277:7;9267;:17;:::i;:::-;9262:44;;9255:52;;;;:::i;:::-;9320:18;9357:7;9341:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9341:25:0;-1:-1:-1;9320:46:0;-1:-1:-1;9320:46:0;9377:22;9466:7;9447:120;9485:17;9495:7;9485;:17;:::i;:::-;9476:1;:27;9447:120;;;9542:10;9553:1;9542:13;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;9542:13:0;9525:9;9535:3;;;;:::i;:::-;;;9525:14;;;;;;;;:::i;:::-;;;;:30;-1:-1:-1;;;;;9525:30:0;;;;;;;;-1:-1:-1;9505:3:0;;;;:::i;:::-;;;;9447:120;;;-1:-1:-1;9593:9:0;;-1:-1:-1;;;;9061:550:0;;;;;;:::o;17912:1001::-;18069:4;18063:11;18129:4;18123;18119:15;18111:23;;18177:6;18171:4;18167:17;18247:4;18238:6;18232:13;18228:24;18220:6;18216:37;18088:712;18278:7;18272:4;18269:17;18088:712;;;18773:11;;18758:27;;18324:4;18314:15;;;;18357:17;18088:712;;;-1:-1:-1;;18872:13:0;;18868:26;18853:42;;;-1:-1:-1;17912:1001:0:o;32714:922::-;32767:7;;-1:-1:-1;;;32845:15:0;;32841:102;;-1:-1:-1;;;32881:15:0;;;-1:-1:-1;32925:2:0;32915:12;32841:102;32970:6;32961:5;:15;32957:102;;33006:6;32997:15;;;-1:-1:-1;33041:2:0;33031:12;32957:102;33086:6;33077:5;:15;33073:102;;33122:6;33113:15;;;-1:-1:-1;33157:2:0;33147:12;33073:102;33202:5;33193;:14;33189:99;;33237:5;33228:14;;;-1:-1:-1;33271:1:0;33261:11;33189:99;33315:5;33306;:14;33302:99;;33350:5;33341:14;;;-1:-1:-1;33384:1:0;33374:11;33302:99;33428:5;33419;:14;33415:99;;33463:5;33454:14;;;-1:-1:-1;33497:1:0;33487:11;33415:99;33541:5;33532;:14;33528:66;;33577:1;33567:11;33622:6;32714:922;-1:-1:-1;;32714:922:0:o;69156:742::-;69366:346;;;-1:-1:-1;;;;;27531:15:1;;69366:346:0;;;;27513:34:1;;;;69461:12:0;27563:18:1;;;27556:34;69640:4:0;27606:18:1;;;27599:43;27658:18;;;;27651:34;;;69366:346:0;;;;;;;;;;27447:19:1;;;;69366:346:0;;;69338:389;;;;;-1:-1:-1;;;69771:37:0;27651:34:1;69338:389:0;69771:37;:::i;:::-;69749:59;;69826:64;69851:11;69864:25;69826:24;:64::i;:::-;69819:71;69156:742;-1:-1:-1;;;;;69156:742:0:o;67844:304::-;67995:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;67995:21:0;-1:-1:-1;;;;;67995:21:0;;;;;;;;68042:33;;67995:16;;;68042:33;;67995:16;;68042:33;82111:483;82066:528;:::o;74458:799::-;74613:4;-1:-1:-1;;;;;74634:13:0;;42863:19;:23;74630:620;;74670:72;;-1:-1:-1;;;74670:72:0;;-1:-1:-1;;;;;74670:36:0;;;;;:72;;38501:10;;74721:4;;74727:7;;74736:5;;74670:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74670:72:0;;;;;;;;-1:-1:-1;;74670:72:0;;;;;;;;;;;;:::i;:::-;;;74666:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74912:6;:13;74929:1;74912:18;74908:272;;74955:60;;-1:-1:-1;;;74955:60:0;;;;;;;:::i;74908:272::-;75130:6;75124:13;75115:6;75111:2;75107:15;75100:38;74666:529;-1:-1:-1;;;;;;74793:51:0;-1:-1:-1;;;74793:51:0;;-1:-1:-1;74786:58:0;;74630:620;-1:-1:-1;75234:4:0;74458:799;;;;;;:::o;546:3097::-;604:13;841:4;:11;856:1;841:16;837:31;;-1:-1:-1;;859:9:0;;;;;;;;;-1:-1:-1;859:9:0;;;546:3097::o;837:31::-;921:19;943:6;;;;;;;;;;;;;;;;;921:28;;1360:20;1419:1;1400:4;:11;1414:1;1400:15;;;;:::i;:::-;1399:21;;;;:::i;:::-;1394:27;;:1;:27;:::i;:::-;1383:39;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1383:39:0;;1360:62;;1602:1;1595:5;1591:13;1706:2;1698:6;1694:15;1817:4;1869;1863:11;1857:4;1853:22;1779:1432;1903:6;1894:7;1891:19;1779:1432;;;2009:1;2000:7;1996:15;1985:26;;2048:7;2042:14;2701:4;2693:5;2689:2;2685:14;2681:25;2671:8;2667:40;2661:47;2650:9;2642:67;2755:1;2744:9;2740:17;2727:30;;2847:4;2839:5;2835:2;2831:14;2827:25;2817:8;2813:40;2807:47;2796:9;2788:67;2901:1;2890:9;2886:17;2873:30;;2992:4;2984:5;2981:1;2977:13;2973:24;2963:8;2959:39;2953:46;2942:9;2934:66;3046:1;3035:9;3031:17;3018:30;;3129:4;3122:5;3118:16;3108:8;3104:31;3098:38;3087:9;3079:58;;3183:1;3172:9;3168:17;3155:30;;1779:1432;;;1783:107;;3373:1;3366:4;3360:11;3356:19;3394:1;3389:123;;;;3531:1;3526:73;;;;3349:250;;3389:123;3442:4;3438:1;3427:9;3423:17;3415:32;3492:4;3488:1;3477:9;3473:17;3465:32;3389:123;;3526:73;3579:4;3575:1;3564:9;3560:17;3552:32;3349:250;-1:-1:-1;3629:6:0;;546:3097;-1:-1:-1;;;;;546:3097:0:o;6815:478::-;7065:18;;6940:3;;6988:5;;7038:6;;7087:1;7065:23;7058:31;;;;:::i;:::-;7116:7;7102:162;7129:10;:17;7125:1;:21;7102:162;;;7189:11;7201:1;7189:14;;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;7172:31:0;;:10;7183:1;7172:13;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;7172:13:0;:31;7168:85;;7235:1;-1:-1:-1;7224:13:0;;-1:-1:-1;;7224:13:0;7168:85;7148:3;;;;:::i;:::-;;;;7102:162;;;-1:-1:-1;;;7283:2:0;6815:478;-1:-1:-1;;;;;;6815:478:0:o;70016:1476::-;70138:7;70184:28;;;:16;:28;;;;;;70138:7;70252:15;;;70248:292;;-1:-1:-1;70365:10:0;70248:292;;;-1:-1:-1;70518:10:0;70248:292;70552:17;70572:29;70600:1;70572:25;:29;:::i;:::-;70612:22;70637:27;;;:16;:27;;;;;;70552:49;;-1:-1:-1;70679:23:0;;;70675:629;;70930:14;70948:1;70930:19;70926:367;;71046:28;;;;:16;:28;;;;;:40;;;70926:367;;;71232:28;;;;:16;:28;;;;;:45;;;70926:367;71318:19;;71314:137;;71412:27;;;;:16;:27;;;;;71405:34;71314:137;-1:-1:-1;71478:6:0;;70016:1476;-1:-1:-1;;;;;70016:1476:0:o;196:131:1:-;-1:-1:-1;;;;;;270:32:1;;260:43;;250:71;;317:1;314;307:12;332:245;390:6;443:2;431:9;422:7;418:23;414:32;411:52;;;459:1;456;449:12;411:52;498:9;485:23;517:30;541:5;517:30;:::i;774:272::-;832:6;885:2;873:9;864:7;860:23;856:32;853:52;;;901:1;898;891:12;853:52;940:9;927:23;990:6;983:5;979:18;972:5;969:29;959:57;;1012:1;1009;1002:12;1051:250;1136:1;1146:113;1160:6;1157:1;1154:13;1146:113;;;1236:11;;;1230:18;1217:11;;;1210:39;1182:2;1175:10;1146:113;;;-1:-1:-1;;1293:1:1;1275:16;;1268:27;1051:250::o;1306:271::-;1348:3;1386:5;1380:12;1413:6;1408:3;1401:19;1429:76;1498:6;1491:4;1486:3;1482:14;1475:4;1468:5;1464:16;1429:76;:::i;:::-;1559:2;1538:15;-1:-1:-1;;1534:29:1;1525:39;;;;1566:4;1521:50;;1306:271;-1:-1:-1;;1306:271:1:o;1582:220::-;1731:2;1720:9;1713:21;1694:4;1751:45;1792:2;1781:9;1777:18;1769:6;1751:45;:::i;1807:180::-;1866:6;1919:2;1907:9;1898:7;1894:23;1890:32;1887:52;;;1935:1;1932;1925:12;1887:52;-1:-1:-1;1958:23:1;;1807:180;-1:-1:-1;1807:180:1:o;2200:173::-;2268:20;;-1:-1:-1;;;;;2317:31:1;;2307:42;;2297:70;;2363:1;2360;2353:12;2297:70;2200:173;;;:::o;2378:254::-;2446:6;2454;2507:2;2495:9;2486:7;2482:23;2478:32;2475:52;;;2523:1;2520;2513:12;2475:52;2546:29;2565:9;2546:29;:::i;:::-;2536:39;2622:2;2607:18;;;;2594:32;;-1:-1:-1;;;2378:254:1:o;2637:186::-;2696:6;2749:2;2737:9;2728:7;2724:23;2720:32;2717:52;;;2765:1;2762;2755:12;2717:52;2788:29;2807:9;2788:29;:::i;2828:328::-;2905:6;2913;2921;2974:2;2962:9;2953:7;2949:23;2945:32;2942:52;;;2990:1;2987;2980:12;2942:52;3013:29;3032:9;3013:29;:::i;:::-;3003:39;;3061:38;3095:2;3084:9;3080:18;3061:38;:::i;:::-;3051:48;;3146:2;3135:9;3131:18;3118:32;3108:42;;2828:328;;;;;:::o;3161:347::-;3226:6;3234;3287:2;3275:9;3266:7;3262:23;3258:32;3255:52;;;3303:1;3300;3293:12;3255:52;3326:29;3345:9;3326:29;:::i;:::-;3316:39;;3405:2;3394:9;3390:18;3377:32;3452:5;3445:13;3438:21;3431:5;3428:32;3418:60;;3474:1;3471;3464:12;3418:60;3497:5;3487:15;;;3161:347;;;;;:::o;3513:127::-;3574:10;3569:3;3565:20;3562:1;3555:31;3605:4;3602:1;3595:15;3629:4;3626:1;3619:15;3645:275;3716:2;3710:9;3781:2;3762:13;;-1:-1:-1;;3758:27:1;3746:40;;3816:18;3801:34;;3837:22;;;3798:62;3795:88;;;3863:18;;:::i;:::-;3899:2;3892:22;3645:275;;-1:-1:-1;3645:275:1:o;3925:186::-;3973:4;4006:18;3998:6;3995:30;3992:56;;;4028:18;;:::i;:::-;-1:-1:-1;4094:2:1;4073:15;-1:-1:-1;;4069:29:1;4100:4;4065:40;;3925:186::o;4116:888::-;4211:6;4219;4227;4235;4288:3;4276:9;4267:7;4263:23;4259:33;4256:53;;;4305:1;4302;4295:12;4256:53;4328:29;4347:9;4328:29;:::i;:::-;4318:39;;4376:38;4410:2;4399:9;4395:18;4376:38;:::i;:::-;4366:48;;4461:2;4450:9;4446:18;4433:32;4423:42;;4516:2;4505:9;4501:18;4488:32;4543:18;4535:6;4532:30;4529:50;;;4575:1;4572;4565:12;4529:50;4598:22;;4651:4;4643:13;;4639:27;-1:-1:-1;4629:55:1;;4680:1;4677;4670:12;4629:55;4716:2;4703:16;4741:48;4757:31;4785:2;4757:31;:::i;:::-;4741:48;:::i;:::-;4812:2;4805:5;4798:17;4852:7;4847:2;4842;4838;4834:11;4830:20;4827:33;4824:53;;;4873:1;4870;4863:12;4824:53;4928:2;4923;4919;4915:11;4910:2;4903:5;4899:14;4886:45;4972:1;4967:2;4962;4955:5;4951:14;4947:23;4940:34;4993:5;4983:15;;;;;4116:888;;;;;;;:::o;5233:260::-;5301:6;5309;5362:2;5350:9;5341:7;5337:23;5333:32;5330:52;;;5378:1;5375;5368:12;5330:52;5401:29;5420:9;5401:29;:::i;:::-;5391:39;;5449:38;5483:2;5472:9;5468:18;5449:38;:::i;:::-;5439:48;;5233:260;;;;;:::o;5498:127::-;5559:10;5554:3;5550:20;5547:1;5540:31;5590:4;5587:1;5580:15;5614:4;5611:1;5604:15;5630:127;5691:10;5686:3;5682:20;5679:1;5672:31;5722:4;5719:1;5712:15;5746:4;5743:1;5736:15;5762:197;5803:3;5841:5;5835:12;5856:65;5914:6;5909:3;5902:4;5895:5;5891:16;5856:65;:::i;:::-;5937:16;;;;;5762:197;-1:-1:-1;;5762:197:1:o;5964:494::-;6141:3;6179:6;6173:13;6195:66;6254:6;6249:3;6242:4;6234:6;6230:17;6195:66;:::i;:::-;6324:13;;6283:16;;;;6346:70;6324:13;6283:16;6393:4;6381:17;;6346:70;:::i;:::-;6432:20;;5964:494;-1:-1:-1;;;;5964:494:1:o;6463:127::-;6524:10;6519:3;6515:20;6512:1;6505:31;6555:4;6552:1;6545:15;6579:4;6576:1;6569:15;6595:135;6634:3;6655:17;;;6652:43;;6675:18;;:::i;:::-;-1:-1:-1;6722:1:1;6711:13;;6595:135::o;6735:450::-;6965:3;7003:6;6997:13;7019:66;7078:6;7073:3;7066:4;7058:6;7054:17;7019:66;:::i;:::-;-1:-1:-1;;;7107:16:1;;7132:18;;;-1:-1:-1;7177:1:1;7166:13;;6735:450;-1:-1:-1;6735:450:1:o;7190:380::-;7269:1;7265:12;;;;7312;;;7333:61;;7387:4;7379:6;7375:17;7365:27;;7333:61;7440:2;7432:6;7429:14;7409:18;7406:38;7403:161;;7486:10;7481:3;7477:20;7474:1;7467:31;7521:4;7518:1;7511:15;7549:4;7546:1;7539:15;7403:161;;7190:380;;;:::o;8815:128::-;8882:9;;;8903:11;;;8900:37;;;8917:18;;:::i;8948:413::-;9150:2;9132:21;;;9189:2;9169:18;;;9162:30;9228:34;9223:2;9208:18;;9201:62;-1:-1:-1;;;9294:2:1;9279:18;;9272:47;9351:3;9336:19;;8948:413::o;10935:320::-;11010:5;11039:52;11055:35;11083:6;11055:35;:::i;11039:52::-;11030:61;;11114:6;11107:5;11100:21;11154:3;11145:6;11140:3;11136:16;11133:25;11130:45;;;11171:1;11168;11161:12;11130:45;11184:65;11242:6;11235:4;11228:5;11224:16;11219:3;11184:65;:::i;11260:457::-;11339:6;11392:2;11380:9;11371:7;11367:23;11363:32;11360:52;;;11408:1;11405;11398:12;11360:52;11441:9;11435:16;11474:18;11466:6;11463:30;11460:50;;;11506:1;11503;11496:12;11460:50;11529:22;;11582:4;11574:13;;11570:27;-1:-1:-1;11560:55:1;;11611:1;11608;11601:12;11560:55;11634:77;11703:7;11698:2;11692:9;11687:2;11683;11679:11;11634:77;:::i;11722:168::-;11795:9;;;11826;;11843:15;;;11837:22;;11823:37;11813:71;;11864:18;;:::i;11895:125::-;11960:9;;;11981:10;;;11978:36;;;11994:18;;:::i;12025:1355::-;-1:-1:-1;;;12674:43:1;;12740:13;;12656:3;;12762:74;12740:13;12825:1;12816:11;;12809:4;12797:17;;12762:74;:::i;:::-;-1:-1:-1;;;12895:1:1;12855:16;;;12887:10;;;12880:42;12947:13;;12969:76;12947:13;13031:2;13023:11;;13016:4;13004:17;;12969:76;:::i;:::-;-1:-1:-1;;;13105:2:1;13064:17;;;;13097:11;;;13090:51;13166:13;;13188:76;13166:13;13250:2;13242:11;;13235:4;13223:17;;13188:76;:::i;:::-;-1:-1:-1;;;13324:2:1;13283:17;;;;13316:11;;;13309:38;13371:2;13363:11;;12025:1355;-1:-1:-1;;;;;12025:1355:1:o;17061:284::-;17154:6;17207:2;17195:9;17186:7;17182:23;17178:32;17175:52;;;17223:1;17220;17213:12;17175:52;17255:9;17249:16;17294:2;17287:5;17284:13;17274:41;;17311:1;17308;17301:12;17350:352;17505:2;17490:18;;17538:2;17527:14;;17517:145;;17584:10;17579:3;17575:20;17572:1;17565:31;17619:4;17616:1;17609:15;17647:4;17644:1;17637:15;17517:145;17671:25;;;17350:352;:::o;17707:283::-;17799:6;17852:2;17840:9;17831:7;17827:23;17823:32;17820:52;;;17868:1;17865;17858:12;17820:52;17900:9;17894:16;17939:2;17932:5;17929:13;17919:41;;17956:1;17953;17946:12;17995:136;18034:3;18062:5;18052:39;;18071:18;;:::i;:::-;-1:-1:-1;;;18107:18:1;;17995:136::o;18136:1012::-;-1:-1:-1;;;18636:55:1;;18714:13;;18618:3;;18736:75;18714:13;18799:2;18790:12;;18783:4;18771:17;;18736:75;:::i;:::-;-1:-1:-1;;;18870:2:1;18830:16;;;18862:11;;;18855:57;18937:13;;18959:76;18937:13;19021:2;19013:11;;19006:4;18994:17;;18959:76;:::i;:::-;-1:-1:-1;;;19095:2:1;19054:17;;;;19087:11;;;19080:35;19139:2;19131:11;;18136:1012;-1:-1:-1;;;;18136:1012:1:o;21506:127::-;21567:10;21562:3;21558:20;21555:1;21548:31;21598:4;21595:1;21588:15;21622:4;21619:1;21612:15;23524:414;23726:2;23708:21;;;23765:2;23745:18;;;23738:30;23804:34;23799:2;23784:18;;23777:62;-1:-1:-1;;;23870:2:1;23855:18;;23848:48;23928:3;23913:19;;23524:414::o;23943:442::-;-1:-1:-1;;;24200:3:1;24193:25;24175:3;24247:6;24241:13;24263:75;24331:6;24326:2;24321:3;24317:12;24310:4;24302:6;24298:17;24263:75;:::i;:::-;24358:16;;;;24376:2;24354:25;;23943:442;-1:-1:-1;;23943:442:1:o;24509:1911::-;-1:-1:-1;;;25404:16:1;;-1:-1:-1;;;25445:1:1;25436:11;;25429:49;25501:13;;-1:-1:-1;;25523:74:1;25501:13;25586:1;25577:11;;25570:4;25558:17;;25523:74;:::i;:::-;-1:-1:-1;;;25656:1:1;25616:16;;;25648:10;;;25641:66;25732:13;;25754:76;25732:13;25816:2;25808:11;;25801:4;25789:17;;25754:76;:::i;:::-;25895:66;25890:2;25849:17;;;;25882:11;;;25875:87;25991:66;25986:2;25978:11;;25971:87;-1:-1:-1;;;26082:2:1;26074:11;;26067:29;26121:13;;26143:76;26121:13;26205:2;26197:11;;26190:4;26178:17;;26143:76;:::i;:::-;-1:-1:-1;;;26279:2:1;26238:17;;;;26271:11;;;26264:65;26345:69;26375:38;26408:3;26400:12;;26392:6;26375:38;:::i;:::-;-1:-1:-1;;;24455:16:1;;24496:1;24487:11;;24390:114;26345:69;26338:76;24509:1911;-1:-1:-1;;;;;;;24509:1911:1:o;26425:461::-;26687:31;26682:3;26675:44;26657:3;26748:6;26742:13;26764:75;26832:6;26827:2;26822:3;26818:12;26811:4;26803:6;26799:17;26764:75;:::i;:::-;26859:16;;;;26877:2;26855:25;;26425:461;-1:-1:-1;;26425:461:1:o;26891:216::-;26955:9;;;26983:11;;;26930:3;27013:9;;27041:10;;27037:19;;27066:10;;27058:19;;27034:44;27031:70;;;27081:18;;:::i;:::-;27031:70;;26891:216;;;;:::o;27112:127::-;27173:10;27168:3;27164:20;27161:1;27154:31;27204:4;27201:1;27194:15;27228:4;27225:1;27218:15;27696:112;27728:1;27754;27744:35;;27759:18;;:::i;:::-;-1:-1:-1;27793:9:1;;27696:112::o;27813:489::-;-1:-1:-1;;;;;28082:15:1;;;28064:34;;28134:15;;28129:2;28114:18;;28107:43;28181:2;28166:18;;28159:34;;;28229:3;28224:2;28209:18;;28202:31;;;28007:4;;28250:46;;28276:19;;28268:6;28250:46;:::i;:::-;28242:54;27813:489;-1:-1:-1;;;;;;27813:489:1:o;28307:249::-;28376:6;28429:2;28417:9;28408:7;28404:23;28400:32;28397:52;;;28445:1;28442;28435:12;28397:52;28477:9;28471:16;28496:30;28520:5;28496:30;:::i;28561:120::-;28601:1;28627;28617:35;;28632:18;;:::i;:::-;-1:-1:-1;28666:9:1;;28561:120::o

ipfs://42544d97c4d7a236e97829ffbd0559bfcdc2cf75b8b5293a51ff4bd28529de9e