Token Punks on Arbitrum

/**
 *Submitted for verification at Etherscan.io on 2023-03-06
*/

// 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/ArbiPunksOnChain.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 PunksonArbitrum 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 - Fully stored on the Arbitrum Blockchain";

    PunkDataInterface private immutable punkDataContract;
    ExtendedPunkDataInterface private immutable extendedPunkDataContract;

/// OnChain Variables - end


/// Mint variables
    uint     public mintPrice    = 0.001 ether;
    uint     public freeAmount   = 1000;
    uint     public freeCount    = 0;
    bool     public mintEnabled  = false;

    mapping(address => bool) public FreeAddresses;

    constructor(address punkDataContractAddress, address extendedPunkDataContractAddress) 
    ERC721r("Punks on Arbitrum", "APUNK", 10000) {

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

    }
    

    function mint(uint256 count) external payable  {
        
        uint256 cost = mintPrice;

        require(mintEnabled, "Mint not ready yet");
        require(totalSupply() + count <= maxSupply(), "Sold Out!");
        require(msg.value >= count * cost, "Please send the exact ETH amount");
        require(msg.sender == tx.origin, "The minter is another contract");

        _mintRandom(msg.sender, count);

    }

    function free_mint() external  {
        uint256 count = 1;
        
        require(FreeAddresses[msg.sender] == false, "Free Mint already claimed");
        require(freeCount < freeAmount, "Free sold out - Mint a paid!");
        require(mintEnabled, "Mint is not live yet");
        require(totalSupply() + count <= maxSupply(), "Sold Out!");
        require(msg.sender == tx.origin, "The minter is another contract");

        freeCount = freeCount + 1;
        FreeAddresses[msg.sender] = true;
        _mintRandom(msg.sender, count);

    }

    function set_Price(uint _price) public onlyOwner {
        mintPrice = _price;            
    }

    function set_freeAmount(uint _freeAmount) public onlyOwner {
        freeAmount = _freeAmount;            
    }

    function toggle_Minting() external onlyOwner {
        mintEnabled = !mintEnabled;
    }

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

    function team_mint() external onlyOwner nonReentrant {
        _mintRandom(msg.sender, 100);

    }


// 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("ArbiPunk #", tokenId.toString());
        
        return
            string(
                abi.encodePacked(
                    "data:application/json;base64,",
                    Base64.encode(
                        bytes(
                            abi.encodePacked(
                                '{',
                                '"name":"', title, '",'
                                '"description":"', tokenDescription, '",'
                                '"background_color":"28A0F0",'
                                '"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="#28A0F0" /><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":"FreeAddresses","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"free_mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"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":"mintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"punkId","type":"uint16"}],"name":"punkAttributesAsJSON","outputs":[{"internalType":"string","name":"json","type":"string"}],"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":"_price","type":"uint256"}],"name":"set_Price","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_freeAmount","type":"uint256"}],"name":"set_freeAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"team_mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggle_Minting","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

78654:15146:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61195:305;;;;;;;;;;-1:-1:-1;61195:305:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;61195:305:0;;;;;;;;90562:1172;;;;;;;;;;-1:-1:-1;90562:1172:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;81286:35::-;;;;;;;;;;;;;;;;;;;1771:25:1;;;1759:2;1744:18;81286:35:0;1625:177:1;62378:100:0;;;;;;;;;;;;;:::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;:::-;;61512:119;;;;;;;;;;;;;:::i;64689:339::-;;;;;;;;;;-1:-1:-1;64689:339:0;;;;;:::i;:::-;;:::i;83125:186::-;;;;;;;;;;;;;:::i;65099:185::-;;;;;;;;;;-1:-1:-1;65099:185:0;;;;;:::i;:::-;;:::i;83319:102::-;;;;;;;;;;;;;:::i;83464:101::-;;;;;;;;;;-1:-1:-1;83464:101:0;;;;;:::i;:::-;;:::i;62072:239::-;;;;;;;;;;-1:-1:-1;62072:239:0;;;;;:::i;:::-;;:::i;81237:42::-;;;;;;;;;;;;;;;;61802:208;;;;;;;;;;-1:-1:-1;61802:208:0;;;;;:::i;:::-;;:::i;40518:103::-;;;;;;;;;;;;;:::i;39870:87::-;;;;;;;;;;-1:-1:-1;39943:6:0;;-1:-1:-1;;;;;39943:6:0;39870:87;;62547:104;;;;;;;;;;;;;:::i;88038:1797::-;;;;;;;;;;-1:-1:-1;88038:1797:0;;;;;:::i;:::-;;:::i;83027:90::-;;;;;;;;;;;;;:::i;81797:427::-;;;;;;:::i;:::-;;:::i;64232:155::-;;;;;;;;;;-1:-1:-1;64232:155:0;;;;;:::i;:::-;;:::i;82232:559::-;;;;;;;;;;;;;:::i;81328:32::-;;;;;;;;;;;;;;;;65355:328;;;;;;;;;;-1:-1:-1;65355:328:0;;;;;:::i;:::-;;:::i;83573:185::-;;;;;;;;;;-1:-1:-1;83573:185:0;;;;;:::i;:::-;;:::i;81367:36::-;;;;;;;;;;-1:-1:-1;81367:36:0;;;;;;;;82905:114;;;;;;;;;;-1:-1:-1;82905:114:0;;;;;:::i;:::-;;:::i;61643:95::-;;;;;;;;;;-1:-1:-1;61720:10:0;61643:95;;82799:98;;;;;;;;;;-1:-1:-1;82799:98:0;;;;;:::i;:::-;;:::i;64458:164::-;;;;;;;;;;-1:-1:-1;64458:164:0;;;;;:::i;:::-;;:::i;81412:45::-;;;;;;;;;;-1:-1:-1;81412:45:0;;;;;:::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;90562:1172::-;90628:18;90659:16;90678:22;90693:6;90678:14;:22::i;:::-;90659:41;;90711:23;90781:19;:25;;;;;;;;;;;;;-1:-1:-1;;;90781:25:0;;;;;90827:39;:372;;;;;;;;90884:4;:8;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90907:4;:9;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90931:4;:9;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90955:4;:10;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90980:4;:9;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91004:4;:9;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91028:4;:10;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91053:4;:9;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91077:4;:12;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91104:4;:9;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91128:4;:9;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91152:4;:11;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;91178:4;:10;;;90827:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;-1:-1:-1;91212:14:0;91229:24;91248:4;91229:18;:24::i;:::-;91212:41;;91264:10;91296:6;91291:371;91312:2;91308:1;:6;91291:371;;;91336:26;91365:9;91375:1;91365:12;;;;;;;:::i;:::-;;;;;91336:41;;91409:4;91398:15;;;;;;;;:::i;:::-;:7;:15;;;;;;;;:::i;:::-;;91394:257;;91460:6;91468:28;91488:7;91468:19;:28::i;:::-;91443:54;;;;;;;;;:::i;:::-;;;;;;;;;;;;;91434:63;;91530:9;91522:5;:17;91518:118;;;91564:22;;;;;;;;;;;;-1:-1:-1;;;91564:22:0;;;;;;:6;;:17;:22::i;:::-;91609:7;;;:::i;:::-;;;91518:118;-1:-1:-1;91316:3:0;;;:::i;:::-;;;91291:371;;;;91713:6;91696:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;91682:44;;;;;;;;90562: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;;7553:2:1;64035:73:0;;;7535:21:1;7592:2;7572:18;;;7565:30;7631:34;7611:18;;;7604:62;-1:-1:-1;;;7682:18:1;;;7675:42;7734: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;;7966:2:1;63593:57:0;;;7948:21:1;8005:2;7985:18;;;7978:30;8044:34;8024:18;;;8017:62;-1:-1:-1;;;8095:18:1;;;8088:31;8136:19;;63593:57:0;7764: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;;8368:2:1;63663:168:0;;;8350:21:1;8407:2;8387:18;;;8380:30;8446:34;8426:18;;;8419:62;8517:26;8497:18;;;8490:54;8561:19;;63663:168:0;8166: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;83125:186::-;39756:13;:11;:13::i;:::-;21942:21:::1;:19;:21::i;:::-;83207:49:::2;::::0;83189:12:::2;::::0;83207:10:::2;::::0;83230:21:::2;::::0;83189:12;83207:49;83189:12;83207:49;83230:21;83207:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83188:68;;;83275:7;83267:36;;;::::0;-1:-1:-1;;;83267:36:0;;9554:2:1;83267:36:0::2;::::0;::::2;9536:21:1::0;9593:2;9573:18;;;9566:30;-1:-1:-1;;;9612:18:1;;;9605:46;9668:18;;83267:36:0::2;9352:340:1::0;83267:36:0::2;83177:134;21986:20:::1;21380:1:::0;22506:7;:22;22323:213;21986:20:::1;83125:186::o:0;65099:185::-;65237:39;65254:4;65260:2;65264:7;65237:39;;;;;;;;;;;;:16;:39::i;83319:102::-;39756:13;:11;:13::i;:::-;21942:21:::1;:19;:21::i;:::-;83383:28:::2;83395:10;83407:3;83383:11;:28::i;:::-;21986:20:::1;21380:1:::0;22506:7;:22;22323:213;83464:101;83517:4;67282:16;;;:7;:16;;;;;;-1:-1:-1;;;;;67282:16:0;:30;;83541: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;;9899:2:1;62207:73:0;;;9881:21:1;9938:2;9918:18;;;9911:30;9977:34;9957:18;;;9950:62;-1:-1:-1;;;10028:18:1;;;10021:39;10077:19;;62207:73:0;9697:405:1;61802:208:0;61874:7;-1:-1:-1;;;;;61902:19:0;;61894:74;;;;-1:-1:-1;;;61894:74:0;;10309:2:1;61894:74:0;;;10291:21:1;10348:2;10328:18;;;10321:30;10387:34;10367:18;;;10360:62;-1:-1:-1;;;10438:18:1;;;10431:40;10488:19;;61894:74:0;10107: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;62547:104::-:0;62603:13;62636:7;62629:14;;;;;:::i;88038:1797::-;88143:43;;-1:-1:-1;;;88143:43:0;;10692:6:1;10680:19;;88143:43:0;;;10662:38:1;88095:13:0;;88121:19;;-1:-1:-1;;;;;88143:16:0;:26;;;;10635:18:1;;88143:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;88143:43:0;;;;;;;;;;;;:::i;:::-;16834:4;16828:11;;17147:20;;;17185:25;;;17323:19;17360:25;;88197:21;17515:4;17500:20;;;17579:17;;;88121:65;;-1:-1:-1;88197:58:0;88276:328;;;;;;;;;;;;;;;;;;:8;;:19;:328::i;:::-;88647:12;;;88657:1;88647:12;;;;;;;;;88625:19;;88647:12;;;;;;;;;;-1:-1:-1;88647:12:0;88625:34;;88675:9;88670:1070;88694:2;88690:1;:6;88670:1070;;;88723:9;88718:1011;88742:2;88738:1;:6;88718:1011;;;88770:9;88792:1;88783:6;:1;88787:2;88783:6;:::i;:::-;:10;;;;:::i;:::-;88782:16;;88797:1;88782:16;:::i;:::-;88770:28;-1:-1:-1;88844:1:0;88827:6;88834:5;88770:28;88838:1;88834:5;:::i;:::-;88827:13;;;;;;;;:::i;:::-;;;;;;;88821:24;88817:897;;;88875:9;88870:321;88894:1;88890;:5;88870:321;;;88929:11;88949:6;88956:5;88960:1;88956;:5;:::i;:::-;88949:13;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;;;;89057:3:0;89049:11;;89036:25;;;;;;;:::i;:::-;;;;89016:6;89023:5;:1;89027;89023:5;:::i;:::-;:9;;89031:1;89023:9;:::i;:::-;89016:17;;;;;;;;:::i;:::-;;;;:45;-1:-1:-1;;;;;89016:45:0;;;;;;;;-1:-1:-1;89098:1:0;89088:11;;;-1:-1:-1;;;89088:11:0;89142:25;;;;;;;:::i;:::-;;;;89126:6;89133:5;:1;89137;89133:5;:::i;:::-;89126:13;;;;;;;;:::i;:::-;;;;:41;-1:-1:-1;;;;;89126:41:0;;;;;;;;;88902:289;88897:3;;;;;:::i;:::-;;;;88870:321;;;-1:-1:-1;89247:6:0;89299:395;89434:12;:1;:10;:12::i;:::-;89515;:1;:10;:12::i;:::-;89600:8;89345:326;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;89345:326:0;;;;;;;;;89299:8;;:19;:395::i;:::-;88847:867;88817:897;-1:-1:-1;88746:3:0;;;;:::i;:::-;;;;88718:1011;;;-1:-1:-1;88698:3:0;;;;:::i;:::-;;;;88670:1070;;;-1:-1:-1;89760:33:0;;;;;;;;;;;;-1:-1:-1;;;89760:33:0;;;;;;:8;;:19;:33::i;:::-;-1:-1:-1;89818:8:0;88038:1797;-1:-1:-1;;;88038:1797:0:o;83027:90::-;39756:13;:11;:13::i;:::-;83098:11:::1;::::0;;-1:-1:-1;;83083:26:0;::::1;83098:11;::::0;;::::1;83097:12;83083:26;::::0;;83027:90::o;81797:427::-;81880:9;;81910:11;;;;81902:42;;;;-1:-1:-1;;;81902:42:0;;13363:2:1;81902:42:0;;;13345:21:1;13402:2;13382:18;;;13375:30;-1:-1:-1;;;13421:18:1;;;13414:48;13479:18;;81902:42:0;13161:342:1;81902:42:0;61720:10;81979:5;81963:13;:11;:13::i;:::-;:21;;;;:::i;:::-;:36;;81955:58;;;;-1:-1:-1;;;81955:58:0;;13710:2:1;81955:58:0;;;13692:21:1;13749:1;13729:18;;;13722:29;-1:-1:-1;;;13767:18:1;;;13760:39;13816:18;;81955:58:0;13508:332:1;81955:58:0;82045:12;82053:4;82045:5;:12;:::i;:::-;82032:9;:25;;82024:70;;;;-1:-1:-1;;;82024:70:0;;14047:2:1;82024:70:0;;;14029:21:1;;;14066:18;;;14059:30;14125:34;14105:18;;;14098:62;14177:18;;82024:70:0;13845:356:1;82024:70:0;82113:10;82127:9;82113:23;82105:66;;;;-1:-1:-1;;;82105:66:0;;14408:2:1;82105:66:0;;;14390:21:1;14447:2;14427:18;;;14420:30;14486:32;14466:18;;;14459:60;14536:18;;82105:66:0;14206:354:1;82105:66:0;82184:30;82196:10;82208:5;82184:11;:30::i;:::-;81844:380;81797:427;:::o;64232:155::-;64327:52;38501:10;64360:8;64370;64327:18;:52::i;82232:559::-;82334:10;82274:13;82320:25;;;:13;:25;;;;;;82290:1;;82320:25;;:34;82312:72;;;;-1:-1:-1;;;82312:72:0;;14767:2:1;82312:72:0;;;14749:21:1;14806:2;14786:18;;;14779:30;14845:27;14825:18;;;14818:55;14890:18;;82312:72:0;14565:349:1;82312:72:0;82415:10;;82403:9;;:22;82395:63;;;;-1:-1:-1;;;82395:63:0;;15121:2:1;82395:63:0;;;15103:21:1;15160:2;15140:18;;;15133:30;15199;15179:18;;;15172:58;15247:18;;82395:63:0;14919:352:1;82395:63:0;82477:11;;;;82469:44;;;;-1:-1:-1;;;82469:44:0;;15478:2:1;82469:44:0;;;15460:21:1;15517:2;15497:18;;;15490:30;-1:-1:-1;;;15536:18:1;;;15529:50;15596:18;;82469:44:0;15276:344:1;82469:44:0;61720:10;82548:5;82532:13;:11;:13::i;:::-;:21;;;;:::i;:::-;:36;;82524:58;;;;-1:-1:-1;;;82524:58:0;;13710:2:1;82524:58:0;;;13692:21:1;13749:1;13729:18;;;13722:29;-1:-1:-1;;;13767:18:1;;;13760:39;13816:18;;82524:58:0;13508:332:1;82524:58:0;82601:10;82615:9;82601:23;82593:66;;;;-1:-1:-1;;;82593:66:0;;14408:2:1;82593:66:0;;;14390:21:1;14447:2;14427:18;;;14420:30;14486:32;14466:18;;;14459:60;14536:18;;82593:66:0;14206:354:1;82593:66:0;82684:9;;:13;;82696:1;82684:13;:::i;:::-;82672:9;:25;82722:10;82708:25;;;;:13;:25;;;;;:32;;-1:-1:-1;;82708:32:0;82736:4;82708:32;;;82751:30;;82775:5;82751:11;:30::i;:::-;82263:528;82232:559::o;65355:328::-;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;83573:185::-;67258:4;67282:16;;;:7;:16;;;;;;83633:13;;-1:-1:-1;;;;;67282:16:0;83659:44;;;;-1:-1:-1;;;83659:44:0;;15827:2:1;83659:44:0;;;15809:21:1;15866:2;15846:18;;;15839:30;-1:-1:-1;;;15885:18:1;;;15878:50;15945:18;;83659:44:0;15625:344:1;83659:44:0;83721:29;83746:2;83721:17;:29::i;82905:114::-;39756:13;:11;:13::i;:::-;82975:10:::1;:24:::0;82905:114::o;82799:98::-;39756:13;:11;:13::i;:::-;82859:9:::1;:18:::0;82799:98::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;;16176:2:1;40857:73:0::1;::::0;::::1;16158:21:1::0;16215:2;16195:18;;;16188:30;16254:34;16234:18;;;16227:62;-1:-1:-1;;;16305:18:1;;;16298:36;16351:19;;40857:73:0::1;15974:402:1::0;40857:73:0::1;40941:28;40960:8;40941:18;:28::i;84856:3107::-:0;84917:11;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;84917:11:0;84960:621;;;;;;;;;;;;;;84941:16;;84960:621;;;84941:16;84960:621;;;;85054:23;84960:621;;;;85098:23;84960:621;;;;85143:23;84960:621;;;;85187:23;84960:621;;;;85231:23;84960:621;;;;85276:23;84960:621;;;;85320:23;84960:621;;;;85367:23;84960:621;;;;85411:23;84960:621;;;;85455:23;84960:621;;;;85501:23;84960:621;;;;85546:23;84960:621;;85602:16;;;;;;85666:40;;-1:-1:-1;;;85666:40:0;;;;;10662:38:1;;;;85602:16:0;;-1:-1:-1;85602:7:0;;85666:16;-1:-1:-1;;;;;85666:31:0;;;;10635:18:1;;85666:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;85666:40:0;;;;;;;;;;;;:::i;:::-;85639:67;;85719:30;85752:21;;;;;;;;;;;;;;-1:-1:-1;;;85752:21:0;;;:10;:16;;:21;;;;:::i;:::-;85719:54;;85799:6;85794:2130;85815:14;:21;85811:1;:25;85794:2130;;;85858:32;85893:14;85908:1;85893:17;;;;;;;;:::i;:::-;;;;;;;85858:52;;85925:30;85992:1;85988;:5;85984:232;;;86033:29;;;;;;;;;;;;-1:-1:-1;;;86033:29:0;;;;;;:18;;:24;:29::i;:::-;86063:1;86033:32;;;;;;;;:::i;:::-;;;;;;;86014:51;;85984:232;;;86125:75;86194:1;86165:18;86159:32;:36;;;;:::i;:::-;86125:18;;86198:1;86125:29;:75::i;:::-;86106:94;;85984:232;86299:66;;-1:-1:-1;;;86299:66:0;;86244:28;;-1:-1:-1;;;;;86299:24:0;:48;;;;:66;;86348:16;;86299:66;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;86294:72;;;;;;;;:::i;:::-;86275:92;;;;;;;;:::i;:::-;86244:123;;86382:26;86434:24;-1:-1:-1;;;;;86434:51:0;;86536:9;86531:15;;;;;;;;:::i;:::-;86486:61;;;;;;;;:::i;:::-;86434:114;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;86429:120;;;;;;;;:::i;:::-;86411:139;;;;;;;;:::i;:::-;86382:168;-1:-1:-1;86595:21:0;86583:8;:33;;;;;;;;:::i;:::-;;86579:1334;;86637:8;;;86648:9;86637:20;;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;86579:1334:0;;;86695:22;86683:8;:34;;;;;;;;:::i;:::-;;86679:1234;;86738:9;;;86750;86738:21;;;;;;;;:::i;86679:1234::-;86797:22;86785:8;:34;;;;;;;;:::i;:::-;;86781:1132;;86840:9;;;86852;86840:21;;;;;;;;:::i;86781:1132::-;86899:23;86887:8;:35;;;;;;;;:::i;:::-;;86883:1030;;86943:10;;;86956:9;86943:22;;;;;;;;:::i;86883:1030::-;87003:22;86991:8;:34;;;;;;;;:::i;:::-;;86987:926;;87046:9;;;87058;87046:21;;;;;;;;:::i;86987:926::-;87105:22;87093:8;:34;;;;;;;;:::i;:::-;;87089:824;;87148:9;;;87160;87148:21;;;;;;;;:::i;87089:824::-;87207:23;87195:8;:35;;;;;;;;:::i;:::-;;87191:722;;87251:10;;;87264:9;87251:22;;;;;;;;:::i;87191:722::-;87311:22;87299:8;:34;;;;;;;;:::i;:::-;;87295:618;;87354:9;;;87366;87354:21;;;;;;;;:::i;87295:618::-;87413:25;87401:8;:37;;;;;;;;:::i;:::-;;87397:516;;87459:12;;;87474:9;87459:24;;;;;;;;:::i;87397:516::-;87521:22;87509:8;:34;;;;;;;;:::i;:::-;;87505:408;;87564:9;;;87576;87564:21;;;;;;;;:::i;87505:408::-;87623:22;87611:8;:34;;;;;;;;:::i;:::-;;87607:306;;87666:9;;;87678;87666:21;;;;;;;;:::i;87607:306::-;87725:24;87713:8;:36;;;;;;;;:::i;:::-;;87709:204;;87770:11;;;87784:9;87770:23;;;;;;;;:::i;87709:204::-;87831:23;87819:8;:35;;;;;;;;:::i;:::-;;87815:98;;87875:10;;;87888:9;87875:22;;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;87815:98:0;85843:2081;;;;85838:3;;;;;:::i;:::-;;;;85794:2130;;;-1:-1:-1;87951:4:0;;84856:3107;-1:-1:-1;;;;84856:3107:0:o;89843:711::-;89911:15;89939:39;:372;;;;;;;;89996:4;:8;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90019:4;:9;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90043:4;:9;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90067:4;:10;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90092:4;:9;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90116:4;:9;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90140:4;:10;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90165:4;:9;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90189:4;:12;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90216:4;:9;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90240:4;:9;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90264:4;:11;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;90290:4;:10;;;89939:372;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;-1:-1:-1;90337:6:0;90332:148;90353:2;90349:1;:6;90332:148;;;90397:23;90381:9;90391:1;90381:12;;;;;;;:::i;:::-;;;;;:39;;;;;;;;:::i;:::-;;90377:92;;90441:12;;;;:::i;:::-;;;;90377:92;90357:3;;;:::i;:::-;;;90332:148;;;-1:-1:-1;90534:12:0;;;;:::i;:::-;;89843:711;-1:-1:-1;;;;89843:711:0:o;91742:2053::-;91824:18;91876:23;91863:9;:36;;;;;;;;:::i;:::-;;91855:45;;;;;;91913:31;91947:24;-1:-1:-1;;;;;91947:48:0;;92046:9;92041:15;;;;;;;;:::i;:::-;91996:61;;;;;;;;:::i;:::-;91947:111;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;91947:111:0;;;;;;;;;;;;:::i;:::-;91913:145;;92069:35;92125:26;92177:24;-1:-1:-1;;;;;92177:51:0;;92279:9;92274:15;;;;;;;;:::i;:::-;92229:61;;;;;;;;:::i;:::-;92177:114;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;92172:120;;;;;;;;:::i;:::-;92154:139;;;;;;;;:::i;:::-;92125:168;-1:-1:-1;92322:21:0;92310:8;:33;;;;;;;;:::i;:::-;;92306:1347;;92360:29;;;;;;;;;;;;;-1:-1:-1;;;92360:29:0;;;;;92306:1347;;;92423:22;92411:8;:34;;;;;;;;:::i;:::-;;92407:1246;;92462:30;;;;;;;;;;;;;-1:-1:-1;;;92462:30:0;;;;;92407:1246;;;92526:22;92514:8;:34;;;;;;;;:::i;:::-;;92510:1143;;92565:30;;;;;;;;;;;;;-1:-1:-1;;;92565:30:0;;;;;92510:1143;;;92629:23;92617:8;:35;;;;;;;;:::i;:::-;;92613:1040;;92669:31;;;;;;;;;;;;;-1:-1:-1;;;92669:31:0;;;;;92613:1040;;;92734:22;92722:8;:34;;;;;;;;:::i;:::-;;92718:935;;92773:30;;;;;;;;;;;;;-1:-1:-1;;;92773:30:0;;;;;92718:935;;;92837:22;92825:8;:34;;;;;;;;:::i;:::-;;92821:832;;92876:30;;;;;;;;;;;;;-1:-1:-1;;;92876:30:0;;;;;92821:832;;;92940:23;92928:8;:35;;;;;;;;:::i;:::-;;92924:729;;92980:31;;;;;;;;;;;;;-1:-1:-1;;;92980:31:0;;;;;92924:729;;;93045:22;93033:8;:34;;;;;;;;:::i;:::-;;93029:624;;93084:30;;;;;;;;;;;;;-1:-1:-1;;;93084:30:0;;;;;93029:624;;;93148:25;93136:8;:37;;;;;;;;:::i;:::-;;93132:521;;93190:33;;;;;;;;;;;;;-1:-1:-1;;;93190:33:0;;;;;93132:521;;;93257:22;93245:8;:34;;;;;;;;:::i;:::-;;93241:412;;93296:30;;;;;;;;;;;;;-1:-1:-1;;;93296:30:0;;;;;93241:412;;;93360:22;93348:8;:34;;;;;;;;:::i;:::-;;93344:309;;93399:30;;;;;;;;;;;;;-1:-1:-1;;;93399:30:0;;;;;93344:309;;;93463:24;93451:8;:36;;;;;;;;:::i;:::-;;93447:206;;93504:32;;;;;;;;;;;;;-1:-1:-1;;;93504:32:0;;;;;93447:206;;;93570:23;93558:8;:35;;;;;;;;:::i;:::-;;93554:99;;93610:31;;;;;;;;;;;;;-1:-1:-1;;;93610:31:0;;;;;93554:99;93723:21;93762:17;93687:99;;;;;;;;;:::i;:::-;;;;;;;;;;;;;93673:114;;;;;91742: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;;19138:2:1;19423:121:0;;;19120:21:1;19177:2;19157:18;;;19150:30;19216:34;19196:18;;;19189:62;-1:-1:-1;;;19267:18:1;;;19260:37;19314:19;;19423:121:0;18936:403:1;19423:121:0;19555:29;19571:6;19579:4;19555:15;:29::i;73267:175::-;73342:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;73342:29:0;-1:-1:-1;;;;;73342:29:0;;;;;;;;:24;;73396;73342;73396:15;:24::i;:::-;-1:-1:-1;;;;;73387:47:0;;;;;;;;;;;73267:175;;:::o;67487:349::-;67580:4;67282:16;;;:7;:16;;;;;;-1:-1:-1;;;;;67282:16:0;67597:73;;;;-1:-1:-1;;;67597:73:0;;19546:2:1;67597:73:0;;;19528:21:1;19585:2;19565:18;;;19558:30;19624:34;19604:18;;;19597:62;-1:-1:-1;;;19675:18:1;;;19668:42;19727:19;;67597:73:0;19344: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;72523:626::-;72683:4;-1:-1:-1;;;;;72655:32:0;:24;72671:7;72655:15;:24::i;:::-;-1:-1:-1;;;;;72655:32:0;;72647:82;;;;-1:-1:-1;;;72647:82:0;;19959:2:1;72647:82:0;;;19941:21:1;19998:2;19978:18;;;19971:30;20037:34;20017:18;;;20010:62;-1:-1:-1;;;20088:18:1;;;20081:35;20133:19;;72647:82:0;19757:401:1;72647:82:0;-1:-1:-1;;;;;72748:16:0;;72740:65;;;;-1:-1:-1;;;72740:65:0;;20365:2:1;72740:65:0;;;20347:21:1;20404:2;20384:18;;;20377:30;20443:34;20423:18;;;20416:62;-1:-1:-1;;;20494:18:1;;;20487:34;20538:19;;72740:65:0;20163:400:1;72740:65:0;72922:29;72939:1;72943:7;72922:8;:29::i;:::-;-1:-1:-1;;;;;72964:15:0;;;;;;:9;:15;;;;;:20;;72983:1;;72964:15;:20;;72983:1;;72964:20;:::i;:::-;;;;-1:-1:-1;;;;;;;72995:13:0;;;;;;:9;:13;;;;;:18;;73012:1;;72995:13;:18;;73012:1;;72995:18;:::i;:::-;;;;-1:-1:-1;;73024:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;73024:21:0;-1:-1:-1;;;;;73024:21:0;;;;;;;;;73063:27;;73024:16;;73063: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;;20770:2:1;40091:68:0;;;20752:21:1;;;20789:18;;;20782:30;20848:34;20828:18;;;20821:62;20900:18;;40091:68:0;20568:356:1;22022:293:0;21424:1;22156:7;;:19;22148:63;;;;-1:-1:-1;;;22148:63:0;;21131:2:1;22148:63:0;;;21113:21:1;21170:2;21150:18;;;21143:30;21209:33;21189:18;;;21182:61;21260:18;;22148:63:0;20929:355:1;22148:63:0;21424:1;22289:7;:18;22022:293::o;68156:984::-;38501:10;68258:9;68242:25;68234:59;;;;-1:-1:-1;;;68234:59:0;;21491:2:1;68234:59:0;;;21473:21:1;21530:2;21510:18;;;21503:30;-1:-1:-1;;;21549:18:1;;;21542:51;21610:18;;68234:59:0;21289:345:1;68234:59:0;-1:-1:-1;;;;;68312:16:0;;68304:61;;;;-1:-1:-1;;;68304:61:0;;21841:2:1;68304:61:0;;;21823:21:1;;;21860:18;;;21853:30;21919:34;21899:18;;;21892:62;21971:18;;68304:61:0;21639:356:1;68304:61:0;68397:1;68384:10;:14;68376:67;;;;-1:-1:-1;;;68376:67:0;;22202:2:1;68376:67:0;;;22184:21:1;22241:2;22221:18;;;22214:30;22280:34;22260:18;;;22253:62;-1:-1:-1;;;22331:18:1;;;22324:38;22379:19;;68376:67:0;22000:404:1;68376:67:0;68597:10;68574:19;;:33;;68566:89;;;;-1:-1:-1;;;68566:89:0;;22611:2:1;68566:89:0;;;22593:21:1;22650:2;22630:18;;;22623:30;22689:34;22669:18;;;22662:62;-1:-1:-1;;;22740:18:1;;;22733:41;22791:19;;68566:89:0;22409: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;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;;73584:315;73739:8;-1:-1:-1;;;;;73730:17:0;:5;-1:-1:-1;;;;;73730:17:0;;73722:55;;;;-1:-1:-1;;;73722:55:0;;23155:2:1;73722:55:0;;;23137:21:1;23194:2;23174:18;;;23167:30;23233:27;23213:18;;;23206:55;23278:18;;73722:55:0;22953:349:1;73722:55:0;-1:-1:-1;;;;;73788:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;73788:46:0;;;;;;;;;;73850:41;;540::1;;;73850::0;;513:18:1;73850:41:0;;;;;;;73584: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;83766:1082::-;83831:13;83857:16;83882:19;83893:7;83882:10;:19::i;:::-;83857:45;;83913:18;83965;:7;:16;;;:18::i;:::-;83934:50;;;;;;;;:::i;:::-;;;;-1:-1:-1;;83934:50:0;;;;;;84384:16;;;;;;;;;;83934:50;;-1:-1:-1;84143:663:0;;83934:50;;84384:16;83934:50;84384:16;;;84548:18;84562:3;84548:13;:18::i;:::-;84657:29;84678:7;84657:20;:29::i;:::-;84219:537;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;84143:13;:663::i;:::-;84050:775;;;;;;;;:::i;:::-;;;;;;;;;;;;;84005:835;;;;83766: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;69156:748::-;69366:352;;;-1:-1:-1;;;;;27219:32:1;;69366:352:0;;;;27201:51:1;;;;27268:18;;;27261:34;;;69366:352:0;;;;;;;;;27174:18:1;;;;69366:352:0;;;69338:395;;;;;-1:-1:-1;;;69777:37:0;27261:34:1;69338:395:0;69777:37;:::i;:::-;69755:59;;69832:64;69857:11;69870:25;69832:24;:64::i;:::-;69825:71;69156:748;-1:-1:-1;;;;;69156:748: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;81844:380;81797:427;:::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;74464:799::-;74619:4;-1:-1:-1;;;;;74640:13:0;;42863:19;:23;74636:620;;74676:72;;-1:-1:-1;;;74676:72:0;;-1:-1:-1;;;;;74676:36:0;;;;;:72;;38501:10;;74727:4;;74733:7;;74742:5;;74676:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74676:72:0;;;;;;;;-1:-1:-1;;74676:72:0;;;;;;;;;;;;:::i;:::-;;;74672:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74918:6;:13;74935:1;74918:18;74914:272;;74961:60;;-1:-1:-1;;;74961:60:0;;;;;;;:::i;74914:272::-;75136:6;75130:13;75121:6;75117:2;75113:15;75106:38;74672:529;-1:-1:-1;;;;;;74799:51:0;-1:-1:-1;;;74799:51:0;;-1:-1:-1;74792:58:0;;74636:620;-1:-1:-1;75240:4:0;74464: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;70022:1476::-;70144:7;70190:28;;;:16;:28;;;;;;70144:7;70258:15;;;70254:292;;-1:-1:-1;70371:10:0;70254:292;;;-1:-1:-1;70524:10:0;70254:292;70558:17;70578:29;70606:1;70578:25;:29;:::i;:::-;70618:22;70643:27;;;:16;:27;;;;;;70558:49;;-1:-1:-1;70685:23:0;;;70681:629;;70936:14;70954:1;70936:19;70932:367;;71052:28;;;;:16;:28;;;;;:40;;;70932:367;;;71238:28;;;;:16;:28;;;;;:45;;;70932:367;71324:19;;71320:137;;71418:27;;;;:16;:27;;;;;71411:34;71320:137;-1:-1:-1;71484:6:0;;70022:1476;-1:-1:-1;;;;;70022:1476:0:o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:272::-;650:6;703:2;691:9;682:7;678:23;674:32;671:52;;;719:1;716;709:12;671:52;758:9;745:23;808:6;801:5;797:18;790:5;787:29;777:57;;830:1;827;820:12;869:250;954:1;964:113;978:6;975:1;972:13;964:113;;;1054:11;;;1048:18;1035:11;;;1028:39;1000:2;993:10;964:113;;;-1:-1:-1;;1111:1:1;1093:16;;1086:27;869:250::o;1124:271::-;1166:3;1204:5;1198:12;1231:6;1226:3;1219:19;1247:76;1316:6;1309:4;1304:3;1300:14;1293:4;1286:5;1282:16;1247:76;:::i;:::-;1377:2;1356:15;-1:-1:-1;;1352:29:1;1343:39;;;;1384:4;1339:50;;1124:271;-1:-1:-1;;1124:271:1:o;1400:220::-;1549:2;1538:9;1531:21;1512:4;1569:45;1610:2;1599:9;1595:18;1587:6;1569: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:328::-;2714:6;2722;2730;2783:2;2771:9;2762:7;2758:23;2754:32;2751:52;;;2799:1;2796;2789:12;2751:52;2822:29;2841:9;2822:29;:::i;:::-;2812:39;;2870:38;2904:2;2893:9;2889:18;2870:38;:::i;:::-;2860:48;;2955:2;2944:9;2940:18;2927:32;2917:42;;2637:328;;;;;:::o;2970:186::-;3029:6;3082:2;3070:9;3061:7;3057:23;3053:32;3050:52;;;3098:1;3095;3088:12;3050:52;3121:29;3140:9;3121:29;:::i;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;5009:260::-;5077:6;5085;5138:2;5126:9;5117:7;5113:23;5109:32;5106:52;;;5154:1;5151;5144:12;5106:52;5177:29;5196:9;5177:29;:::i;:::-;5167:39;;5225:38;5259:2;5248:9;5244:18;5225:38;:::i;:::-;5215:48;;5009:260;;;;;:::o;5274:127::-;5335:10;5330:3;5326:20;5323:1;5316:31;5366:4;5363:1;5356:15;5390:4;5387:1;5380:15;5406:127;5467:10;5462:3;5458:20;5455:1;5448:31;5498:4;5495:1;5488:15;5522:4;5519:1;5512:15;5538:197;5579:3;5617:5;5611:12;5632:65;5690:6;5685:3;5678:4;5671:5;5667:16;5632:65;:::i;:::-;5713:16;;;;;5538:197;-1:-1:-1;;5538:197:1:o;5740:494::-;5917:3;5955:6;5949:13;5971:66;6030:6;6025:3;6018:4;6010:6;6006:17;5971:66;:::i;:::-;6100:13;;6059:16;;;;6122:70;6100:13;6059:16;6169:4;6157:17;;6122:70;:::i;:::-;6208:20;;5740:494;-1:-1:-1;;;;5740:494:1:o;6239:127::-;6300:10;6295:3;6291:20;6288:1;6281:31;6331:4;6328:1;6321:15;6355:4;6352:1;6345:15;6371:135;6410:3;6431:17;;;6428:43;;6451:18;;:::i;:::-;-1:-1:-1;6498:1:1;6487:13;;6371:135::o;6511:450::-;6741:3;6779:6;6773:13;6795:66;6854:6;6849:3;6842:4;6834:6;6830:17;6795:66;:::i;:::-;-1:-1:-1;;;6883:16:1;;6908:18;;;-1:-1:-1;6953:1:1;6942:13;;6511:450;-1:-1:-1;6511:450:1:o;6966:380::-;7045:1;7041:12;;;;7088;;;7109:61;;7163:4;7155:6;7151:17;7141:27;;7109:61;7216:2;7208:6;7205:14;7185:18;7182:38;7179:161;;7262:10;7257:3;7253:20;7250:1;7243:31;7297:4;7294:1;7287:15;7325:4;7322:1;7315:15;7179:161;;6966:380;;;:::o;8591:128::-;8658:9;;;8679:11;;;8676:37;;;8693:18;;:::i;8724:413::-;8926:2;8908:21;;;8965:2;8945:18;;;8938:30;9004:34;8999:2;8984:18;;8977:62;-1:-1:-1;;;9070:2:1;9055:18;;9048:47;9127:3;9112:19;;8724:413::o;10711:320::-;10786:5;10815:52;10831:35;10859:6;10831:35;:::i;10815:52::-;10806:61;;10890:6;10883:5;10876:21;10930:3;10921:6;10916:3;10912:16;10909:25;10906:45;;;10947:1;10944;10937:12;10906:45;10960:65;11018:6;11011:4;11004:5;11000:16;10995:3;10960:65;:::i;11036:457::-;11115:6;11168:2;11156:9;11147:7;11143:23;11139:32;11136:52;;;11184:1;11181;11174:12;11136:52;11217:9;11211:16;11250:18;11242:6;11239:30;11236:50;;;11282:1;11279;11272:12;11236:50;11305:22;;11358:4;11350:13;;11346:27;-1:-1:-1;11336:55:1;;11387:1;11384;11377:12;11336:55;11410:77;11479:7;11474:2;11468:9;11463:2;11459;11455:11;11410:77;:::i;11498:168::-;11571:9;;;11602;;11619:15;;;11613:22;;11599:37;11589:71;;11640:18;;:::i;11671:125::-;11736:9;;;11757:10;;;11754:36;;;11770:18;;:::i;11801:1355::-;-1:-1:-1;;;12450:43:1;;12516:13;;12432:3;;12538:74;12516:13;12601:1;12592:11;;12585:4;12573:17;;12538:74;:::i;:::-;-1:-1:-1;;;12671:1:1;12631:16;;;12663:10;;;12656:42;12723:13;;12745:76;12723:13;12807:2;12799:11;;12792:4;12780:17;;12745:76;:::i;:::-;-1:-1:-1;;;12881:2:1;12840:17;;;;12873:11;;;12866:51;12942:13;;12964:76;12942:13;13026:2;13018:11;;13011:4;12999:17;;12964:76;:::i;:::-;-1:-1:-1;;;13100:2:1;13059:17;;;;13092:11;;;13085:38;13147:2;13139:11;;11801:1355;-1:-1:-1;;;;;11801:1355:1:o;16844:284::-;16937:6;16990:2;16978:9;16969:7;16965:23;16961:32;16958:52;;;17006:1;17003;16996:12;16958:52;17038:9;17032:16;17077:2;17070:5;17067:13;17057:41;;17094:1;17091;17084:12;17133:352;17288:2;17273:18;;17321:2;17310:14;;17300:145;;17367:10;17362:3;17358:20;17355:1;17348:31;17402:4;17399:1;17392:15;17430:4;17427:1;17420:15;17300:145;17454:25;;;17133:352;:::o;17490:283::-;17582:6;17635:2;17623:9;17614:7;17610:23;17606:32;17603:52;;;17651:1;17648;17641:12;17603:52;17683:9;17677:16;17722:2;17715:5;17712:13;17702:41;;17739:1;17736;17729:12;17778:136;17817:3;17845:5;17835:39;;17854:18;;:::i;:::-;-1:-1:-1;;;17890:18:1;;17778:136::o;17919:1012::-;-1:-1:-1;;;18419:55:1;;18497:13;;18401:3;;18519:75;18497:13;18582:2;18573:12;;18566:4;18554:17;;18519:75;:::i;:::-;-1:-1:-1;;;18653:2:1;18613:16;;;18645:11;;;18638:57;18720:13;;18742:76;18720:13;18804:2;18796:11;;18789:4;18777:17;;18742:76;:::i;:::-;-1:-1:-1;;;18878:2:1;18837:17;;;;18870:11;;;18863:35;18922:2;18914:11;;17919:1012;-1:-1:-1;;;;17919:1012:1:o;22821:127::-;22882:10;22877:3;22873:20;22870:1;22863:31;22913:4;22910:1;22903:15;22937:4;22934:1;22927:15;23307:414;23509:2;23491:21;;;23548:2;23528:18;;;23521:30;23587:34;23582:2;23567:18;;23560:62;-1:-1:-1;;;23653:2:1;23638:18;;23631:48;23711:3;23696:19;;23307:414::o;23726:442::-;-1:-1:-1;;;23983:3:1;23976:25;23958:3;24030:6;24024:13;24046:75;24114:6;24109:2;24104:3;24100:12;24093:4;24085:6;24081:17;24046:75;:::i;:::-;24141:16;;;;24159:2;24137:25;;23726:442;-1:-1:-1;;23726:442:1:o;24292:1911::-;-1:-1:-1;;;25187:16:1;;-1:-1:-1;;;25228:1:1;25219:11;;25212:49;25284:13;;-1:-1:-1;;25306:74:1;25284:13;25369:1;25360:11;;25353:4;25341:17;;25306:74;:::i;:::-;-1:-1:-1;;;25439:1:1;25399:16;;;25431:10;;;25424:66;25515:13;;25537:76;25515:13;25599:2;25591:11;;25584:4;25572:17;;25537:76;:::i;:::-;25678:66;25673:2;25632:17;;;;25665:11;;;25658:87;25774:66;25769:2;25761:11;;25754:87;-1:-1:-1;;;25865:2:1;25857:11;;25850:29;25904:13;;25926:76;25904:13;25988:2;25980:11;;25973:4;25961:17;;25926:76;:::i;:::-;-1:-1:-1;;;26062:2:1;26021:17;;;;26054:11;;;26047:65;26128:69;26158:38;26191:3;26183:12;;26175:6;26158:38;:::i;:::-;-1:-1:-1;;;24238:16:1;;24279:1;24270:11;;24173:114;26128:69;26121:76;24292:1911;-1:-1:-1;;;;;;;24292:1911:1:o;26208:461::-;26470:31;26465:3;26458:44;26440:3;26531:6;26525:13;26547:75;26615:6;26610:2;26605:3;26601:12;26594:4;26586:6;26582:17;26547:75;:::i;:::-;26642:16;;;;26660:2;26638:25;;26208:461;-1:-1:-1;;26208:461:1:o;26674:216::-;26738:9;;;26766:11;;;26713:3;26796:9;;26824:10;;26820:19;;26849:10;;26841:19;;26817:44;26814:70;;;26864:18;;:::i;:::-;26814:70;;26674:216;;;;:::o;26895:127::-;26956:10;26951:3;26947:20;26944:1;26937:31;26987:4;26984:1;26977:15;27011:4;27008:1;27001:15;27306:112;27338:1;27364;27354:35;;27369:18;;:::i;:::-;-1:-1:-1;27403:9:1;;27306:112::o;27423:489::-;-1:-1:-1;;;;;27692:15:1;;;27674:34;;27744:15;;27739:2;27724:18;;27717:43;27791:2;27776:18;;27769:34;;;27839:3;27834:2;27819:18;;27812:31;;;27617:4;;27860:46;;27886:19;;27878:6;27860:46;:::i;:::-;27852:54;27423:489;-1:-1:-1;;;;;;27423:489:1:o;27917:249::-;27986:6;28039:2;28027:9;28018:7;28014:23;28010:32;28007:52;;;28055:1;28052;28045:12;28007:52;28087:9;28081:16;28106:30;28130:5;28106:30;:::i;28171:120::-;28211:1;28237;28227:35;;28242:18;;:::i;:::-;-1:-1:-1;28276:9:1;;28171:120::o

ipfs://fec6dd1039d6b2a32fc0a5ac1c3ead7d0538f9b55aea6ee3af8b2c3b4038c10c