p!ranha?

// © 2024 and later: Unicode, Inc. and others. // License & terms of use: https://www.unicode.org/copyright.html // utfiterator.h // created: 2024aug12 Markus W. Scherer #ifndef __UTFITERATOR_H__ #define __UTFITERATOR_H__ #include "unicode/utypes.h" #if U_SHOW_CPLUSPLUS_API || U_SHOW_CPLUSPLUS_HEADER_API || !defined(UTYPES_H) #include <iterator> #if defined(__cpp_lib_ranges) #include <ranges> #endif #include <string> #include <string_view> #include <type_traits> #include "unicode/utf16.h" #include "unicode/utf8.h" #include "unicode/uversion.h" /** * \file * \brief C++ header-only API: C++ iterators over Unicode strings (=UTF-8/16/32 if well-formed). * * Sample code: * \code * #include <string_view> * #include <iostream> * #include "unicode/utypes.h" * #include "unicode/utfiterator.h" * * using icu::header::utfIterator; * using icu::header::utfStringCodePoints; * using icu::header::unsafeUTFIterator; * using icu::header::unsafeUTFStringCodePoints; * * int32_t rangeLoop16(std::u16string_view s) { * // We are just adding up the code points for minimal-code demonstration purposes. * int32_t sum = 0; * for (auto units : utfStringCodePoints<UChar32, UTF_BEHAVIOR_NEGATIVE>(s)) { * sum += units.codePoint(); // < 0 if ill-formed * } * return sum; * } * * int32_t loopIterPlusPlus16(std::u16string_view s) { * auto range = utfStringCodePoints<char32_t, UTF_BEHAVIOR_FFFD>(s); * int32_t sum = 0; * for (auto iter = range.begin(), limit = range.end(); iter != limit;) { * sum += (*iter++).codePoint(); // U+FFFD if ill-formed * } * return sum; * } * * int32_t backwardLoop16(std::u16string_view s) { * auto range = utfStringCodePoints<UChar32, UTF_BEHAVIOR_SURROGATE>(s); * int32_t sum = 0; * for (auto start = range.begin(), iter = range.end(); start != iter;) { * sum += (*--iter).codePoint(); // surrogate code point if unpaired / ill-formed * } * return sum; * } * * int32_t reverseLoop8(std::string_view s) { * auto range = utfStringCodePoints<char32_t, UTF_BEHAVIOR_FFFD>(s); * int32_t sum = 0; * for (auto iter = range.rbegin(), limit = range.rend(); iter != limit; ++iter) { * sum += iter->codePoint(); // U+FFFD if ill-formed * } * return sum; * } * * int32_t countCodePoints16(std::u16string_view s) { * auto range = utfStringCodePoints<UChar32, UTF_BEHAVIOR_SURROGATE>(s); * return std::distance(range.begin(), range.end()); * } * * int32_t unsafeRangeLoop16(std::u16string_view s) { * int32_t sum = 0; * for (auto units : unsafeUTFStringCodePoints<UChar32>(s)) { * sum += units.codePoint(); * } * return sum; * } * * int32_t unsafeReverseLoop8(std::string_view s) { * auto range = unsafeUTFStringCodePoints<UChar32>(s); * int32_t sum = 0; * for (auto iter = range.rbegin(), limit = range.rend(); iter != limit; ++iter) { * sum += iter->codePoint(); * } * return sum; * } * * char32_t firstCodePointOrFFFD16(std::u16string_view s) { * if (s.empty()) { return 0xfffd; } * auto range = utfStringCodePoints<char32_t, UTF_BEHAVIOR_FFFD>(s); * return range.begin()->codePoint(); * } * * std::string_view firstSequence8(std::string_view s) { * if (s.empty()) { return {}; } * auto range = utfStringCodePoints<char32_t, UTF_BEHAVIOR_FFFD>(s); * auto units = *(range.begin()); * if (units.wellFormed()) { * return units.stringView(); * } else { * return {}; * } * } * * template<typename InputStream> // some istream or streambuf * std::u32string cpFromInput(InputStream &in) { * // This is a single-pass input_iterator. * std::istreambuf_iterator bufIter(in); * std::istreambuf_iterator<typename InputStream::char_type> bufLimit; * auto iter = utfIterator<char32_t, UTF_BEHAVIOR_FFFD>(bufIter); * auto limit = utfIterator<char32_t, UTF_BEHAVIOR_FFFD>(bufLimit); * std::u32string s32; * for (; iter != limit; ++iter) { * s32.push_back(iter->codePoint()); * } * return s32; * } * * std::u32string cpFromStdin() { return cpFromInput(std::cin); } * std::u32string cpFromWideStdin() { return cpFromInput(std::wcin); } * \endcode */ #ifndef U_HIDE_DRAFT_API /** * Some defined behaviors for handling ill-formed Unicode strings. * This is a template parameter for UTFIterator and related classes. * * When a validating UTFIterator encounters an ill-formed code unit sequence, * then CodeUnits.codePoint() is a value according to this parameter. * * @draft ICU 78 * @see CodeUnits * @see UTFIterator * @see UTFStringCodePoints */ typedef enum UTFIllFormedBehavior { /** * Returns a negative value (-1=U_SENTINEL) instead of a code point. * If the CP32 template parameter for the relevant classes is an unsigned type, * then the negative value becomes 0xffffffff=UINT32_MAX. * * @draft ICU 78 */ UTF_BEHAVIOR_NEGATIVE, /** Returns U+FFFD Replacement Character. @draft ICU 78 */ UTF_BEHAVIOR_FFFD, /** * UTF-8: Not allowed; * UTF-16: returns the unpaired surrogate; * UTF-32: returns the surrogate code point, or U+FFFD if out of range. * * @draft ICU 78 */ UTF_BEHAVIOR_SURROGATE } UTFIllFormedBehavior; namespace U_HEADER_ONLY_NAMESPACE { namespace prv { #if U_CPLUSPLUS_VERSION >= 20 /** @internal */ template<typename Iter> using iter_value_t = typename std::iter_value_t<Iter>; /** @internal */ template<typename Iter> using iter_difference_t = std::iter_difference_t<Iter>; /** @internal */ template<typename Iter> constexpr bool forward_iterator = std::forward_iterator<Iter>; /** @internal */ template<typename Iter> constexpr bool bidirectional_iterator = std::bidirectional_iterator<Iter>; /** @internal */ template<typename Range> constexpr bool range = std::ranges::range<Range>; #else /** @internal */ template<typename Iter> using iter_value_t = typename std::iterator_traits<Iter>::value_type; /** @internal */ template<typename Iter> using iter_difference_t = typename std::iterator_traits<Iter>::difference_type; /** @internal */ template<typename Iter> constexpr bool forward_iterator = std::is_base_of_v< std::forward_iterator_tag, typename std::iterator_traits<Iter>::iterator_category>; /** @internal */ template<typename Iter> constexpr bool bidirectional_iterator = std::is_base_of_v< std::bidirectional_iterator_tag, typename std::iterator_traits<Iter>::iterator_category>; /** @internal */ template<typename Range, typename = void> struct range_type : std::false_type {}; /** @internal */ template<typename Range> struct range_type< Range, std::void_t<decltype(std::declval<Range>().begin()), decltype(std::declval<Range>().end())>> : std::true_type {}; /** @internal */ template<typename Range> constexpr bool range = range_type<Range>::value; #endif /** @internal */ template <typename T> struct is_basic_string_view : std::false_type {}; /** @internal */ template <typename... Args> struct is_basic_string_view<std::basic_string_view<Args...>> : std::true_type {}; /** @internal */ template <typename T> constexpr bool is_basic_string_view_v = is_basic_string_view<T>::value; /** @internal */ template<typename CP32, bool skipSurrogates> class CodePointsIterator { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: /** C++ iterator boilerplate @internal */ using value_type = CP32; /** C++ iterator boilerplate @internal */ using reference = value_type; /** C++ iterator boilerplate @internal */ using pointer = CP32 *; /** C++ iterator boilerplate @internal */ using difference_type = int32_t; /** C++ iterator boilerplate @internal */ using iterator_category = std::forward_iterator_tag; /** @internal */ inline CodePointsIterator(CP32 c) : c_(c) {} /** @internal */ inline bool operator==(const CodePointsIterator &other) const { return c_ == other.c_; } /** @internal */ inline bool operator!=(const CodePointsIterator &other) const { return !operator==(other); } /** @internal */ inline CP32 operator*() const { return c_; } /** @internal */ inline CodePointsIterator &operator++() { // pre-increment ++c_; if (skipSurrogates && c_ == 0xd800) { c_ = 0xe000; } return *this; } /** @internal */ inline CodePointsIterator operator++(int) { // post-increment CodePointsIterator result(*this); ++(*this); return result; } private: CP32 c_; }; } // namespace prv /** * A C++ "range" over all Unicode code points U+0000..U+10FFFF. * https://www.unicode.org/glossary/#code_point * * Intended for test and builder code. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t * @draft ICU 78 * @see U_IS_CODE_POINT */ template<typename CP32> class AllCodePoints { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: /** Constructor. @draft ICU 78 */ AllCodePoints() {} /** * @return an iterator over all Unicode code points. * The iterator returns CP32 integers. * @draft ICU 78 */ auto begin() const { return prv::CodePointsIterator<CP32, false>(0); } /** * @return an exclusive-end iterator over all Unicode code points. * @draft ICU 78 */ auto end() const { return prv::CodePointsIterator<CP32, false>(0x110000); } }; /** * A C++ "range" over all Unicode scalar values U+0000..U+D7FF & U+E000..U+10FFFF. * That is, all code points except surrogates. * Only scalar values can be represented in well-formed UTF-8/16/32. * https://www.unicode.org/glossary/#unicode_scalar_value * * Intended for test and builder code. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t * @draft ICU 78 * @see U_IS_SCALAR_VALUE */ template<typename CP32> class AllScalarValues { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: /** Constructor. @draft ICU 78 */ AllScalarValues() {} /** * @return an iterator over all Unicode scalar values. * The iterator returns CP32 integers. * @draft ICU 78 */ auto begin() const { return prv::CodePointsIterator<CP32, true>(0); } /** * @return an exclusive-end iterator over all Unicode scalar values. * @draft ICU 78 */ auto end() const { return prv::CodePointsIterator<CP32, true>(0x110000); } }; /** * Result of decoding a code unit sequence for one code point. * Returned from non-validating Unicode string code point iterators. * Base class for class CodeUnits which is returned from validating iterators. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t; * should be signed if UTF_BEHAVIOR_NEGATIVE * @tparam UnitIter An iterator (often a pointer) that returns a code unit type: * UTF-8: char or char8_t or uint8_t; * UTF-16: char16_t or uint16_t or (on Windows) wchar_t; * UTF-32: char32_t or UChar32=int32_t or (on Linux) wchar_t * @see UnsafeUTFIterator * @see UnsafeUTFStringCodePoints * @draft ICU 78 */ template<typename CP32, typename UnitIter, typename = void> class UnsafeCodeUnits { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); using Unit = typename prv::iter_value_t<UnitIter>; public: /** @internal */ UnsafeCodeUnits(CP32 codePoint, uint8_t length, UnitIter start, UnitIter limit) : c_(codePoint), len_(length), start_(start), limit_(limit) {} /** Copy constructor. @draft ICU 78 */ UnsafeCodeUnits(const UnsafeCodeUnits &other) = default; /** Copy assignment operator. @draft ICU 78 */ UnsafeCodeUnits &operator=(const UnsafeCodeUnits &other) = default; /** * @return the Unicode code point decoded from the code unit sequence. * If the sequence is ill-formed and the iterator validates, * then this is a replacement value according to the iterator‘s * UTFIllFormedBehavior template parameter. * @draft ICU 78 */ CP32 codePoint() const { return c_; } /** * @return the start of the code unit sequence for one code point. * Only enabled if UnitIter is a (multi-pass) forward_iterator or better. * @draft ICU 78 */ UnitIter begin() const { return start_; } /** * @return the limit (exclusive end) of the code unit sequence for one code point. * Only enabled if UnitIter is a (multi-pass) forward_iterator or better. * @draft ICU 78 */ UnitIter end() const { return limit_; } /** * @return the length of the code unit sequence for one code point. * @draft ICU 78 */ uint8_t length() const { return len_; } #if U_CPLUSPLUS_VERSION >= 20 /** * @return a string_view of the code unit sequence for one code point. * Only works if UnitIter is a pointer or a contiguous_iterator. * @draft ICU 78 */ template<std::contiguous_iterator Iter = UnitIter> std::basic_string_view<Unit> stringView() const { return std::basic_string_view<Unit>(begin(), end()); } #else /** * @return a string_view of the code unit sequence for one code point. * Only works if UnitIter is a pointer or a contiguous_iterator. * @draft ICU 78 */ template<typename Iter = UnitIter, typename Unit = typename std::iterator_traits<Iter>::value_type> std::enable_if_t<std::is_pointer_v<Iter> || std::is_same_v<Iter, typename std::basic_string<Unit>::iterator> || std::is_same_v<Iter, typename std::basic_string<Unit>::const_iterator> || std::is_same_v<Iter, typename std::basic_string_view<Unit>::iterator> || std::is_same_v<Iter, typename std::basic_string_view<Unit>::const_iterator>, std::basic_string_view<Unit>> stringView() const { return std::basic_string_view<Unit>(&*start_, len_); } #endif private: // Order of fields with padding and access frequency in mind. CP32 c_; uint8_t len_; UnitIter start_; UnitIter limit_; }; #ifndef U_IN_DOXYGEN // Partial template specialization for single-pass input iterator. // No UnitIter field, no getter for it, no stringView(). template<typename CP32, typename UnitIter> class UnsafeCodeUnits< CP32, UnitIter, std::enable_if_t<!prv::forward_iterator<UnitIter>>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: UnsafeCodeUnits(CP32 codePoint, uint8_t length) : c_(codePoint), len_(length) {} UnsafeCodeUnits(const UnsafeCodeUnits &other) = default; UnsafeCodeUnits &operator=(const UnsafeCodeUnits &other) = default; CP32 codePoint() const { return c_; } uint8_t length() const { return len_; } private: // Order of fields with padding and access frequency in mind. CP32 c_; uint8_t len_; }; #endif // U_IN_DOXYGEN /** * Result of validating and decoding a code unit sequence for one code point. * Returned from validating Unicode string code point iterators. * Adds function wellFormed() to base class UnsafeCodeUnits. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t; * should be signed if UTF_BEHAVIOR_NEGATIVE * @tparam UnitIter An iterator (often a pointer) that returns a code unit type: * UTF-8: char or char8_t or uint8_t; * UTF-16: char16_t or uint16_t or (on Windows) wchar_t; * UTF-32: char32_t or UChar32=int32_t or (on Linux) wchar_t * @see UTFIterator * @see UTFStringCodePoints * @draft ICU 78 */ template<typename CP32, typename UnitIter, typename = void> class CodeUnits : public UnsafeCodeUnits<CP32, UnitIter> { public: /** @internal */ CodeUnits(CP32 codePoint, uint8_t length, bool wellFormed, UnitIter start, UnitIter limit) : UnsafeCodeUnits<CP32, UnitIter>(codePoint, length, start, limit), ok_(wellFormed) {} /** Copy constructor. @draft ICU 78 */ CodeUnits(const CodeUnits &other) = default; /** Copy assignment operator. @draft ICU 78 */ CodeUnits &operator=(const CodeUnits &other) = default; /** * @return true if the decoded code unit sequence is well-formed. * @draft ICU 78 */ bool wellFormed() const { return ok_; } private: bool ok_; }; #ifndef U_IN_DOXYGEN // Partial template specialization for single-pass input iterator. // No UnitIter field, no getter for it, no stringView(). template<typename CP32, typename UnitIter> class CodeUnits< CP32, UnitIter, std::enable_if_t<!prv::forward_iterator<UnitIter>>> : public UnsafeCodeUnits<CP32, UnitIter> { public: CodeUnits(CP32 codePoint, uint8_t length, bool wellFormed) : UnsafeCodeUnits<CP32, UnitIter>(codePoint, length), ok_(wellFormed) {} CodeUnits(const CodeUnits &other) = default; CodeUnits &operator=(const CodeUnits &other) = default; bool wellFormed() const { return ok_; } private: bool ok_; }; #endif // U_IN_DOXYGEN // Validating implementations ---------------------------------------------- *** #ifndef U_IN_DOXYGEN template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter, typename LimitIter = UnitIter, typename = void> class UTFImpl; // Note: readAndInc() functions take both a p0 and a p iterator. // They must have the same value. // For a multi-pass UnitIter, the caller must copy its p into a local variable p0, // and readAndInc() copies p0 and the incremented p into the CodeUnits. // For a single-pass UnitIter, which may not be default-constructible nor coypable, // the caller can pass p into both references, and readAndInc() does not use p0 // and constructs CodeUnits without them. // Moving the p0 variable into the call site avoids having to declare it inside readAndInc() // which may not be possible for a single-pass iterator. // UTF-8 template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter, typename LimitIter> class UTFImpl< CP32, behavior, UnitIter, LimitIter, std::enable_if_t<sizeof(typename prv::iter_value_t<UnitIter>) == 1>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); static_assert(behavior != UTF_BEHAVIOR_SURROGATE, "For 8-bit strings, the SURROGATE option does not have an equivalent."); public: // Handle ill-formed UTF-8 U_FORCE_INLINE static CP32 sub() { if constexpr (behavior == UTF_BEHAVIOR_NEGATIVE) { return U_SENTINEL; } else { static_assert(behavior == UTF_BEHAVIOR_FFFD); return 0xfffd; } } U_FORCE_INLINE static void inc(UnitIter &p, const LimitIter &limit) { // Very similar to U8_FWD_1(). uint8_t b = *p; ++p; if (U8_IS_LEAD(b) && p != limit) { uint8_t t1 = *p; if ((0xe0 <= b && b < 0xf0)) { if (U8_IS_VALID_LEAD3_AND_T1(b, t1) && ++p != limit && U8_IS_TRAIL(*p)) { ++p; } } else if (b < 0xe0) { if (U8_IS_TRAIL(t1)) { ++p; } } else /* b >= 0xf0 */ { if (U8_IS_VALID_LEAD4_AND_T1(b, t1) && ++p != limit && U8_IS_TRAIL(*p) && ++p != limit && U8_IS_TRAIL(*p)) { ++p; } } } } U_FORCE_INLINE static void dec(UnitIter start, UnitIter &p) { // Very similar to U8_BACK_1(). uint8_t c = *--p; if (U8_IS_TRAIL(c) && p != start) { UnitIter p1 = p; uint8_t b1 = *--p1; if (U8_IS_LEAD(b1)) { if (b1 < 0xe0 || (b1 < 0xf0 ? U8_IS_VALID_LEAD3_AND_T1(b1, c) : U8_IS_VALID_LEAD4_AND_T1(b1, c))) { p = p1; return; } } else if (U8_IS_TRAIL(b1) && p1 != start) { uint8_t b2 = *--p1; if (0xe0 <= b2 && b2 <= 0xf4) { if (b2 < 0xf0 ? U8_IS_VALID_LEAD3_AND_T1(b2, b1) : U8_IS_VALID_LEAD4_AND_T1(b2, b1)) { p = p1; return; } } else if (U8_IS_TRAIL(b2) && p1 != start) { uint8_t b3 = *--p1; if (0xf0 <= b3 && b3 <= 0xf4 && U8_IS_VALID_LEAD4_AND_T1(b3, b2)) { p = p1; return; } } } } } U_FORCE_INLINE static CodeUnits<CP32, UnitIter> readAndInc( UnitIter &p0, UnitIter &p, const LimitIter &limit) { constexpr bool isMultiPass = prv::forward_iterator<UnitIter>; // Very similar to U8_NEXT_OR_FFFD(). CP32 c = uint8_t(*p); ++p; if (U8_IS_SINGLE(c)) { if constexpr (isMultiPass) { return {c, 1, true, p0, p}; } else { return {c, 1, true}; } } uint8_t length = 1; uint8_t t = 0; if (p != limit && // fetch/validate/assemble all but last trail byte (c >= 0xe0 ? (c < 0xf0 ? // U+0800..U+FFFF except surrogates U8_LEAD3_T1_BITS[c &= 0xf] & (1 << ((t = *p) >> 5)) && (t &= 0x3f, 1) : // U+10000..U+10FFFF (c -= 0xf0) <= 4 && U8_LEAD4_T1_BITS[(t = *p) >> 4] & (1 << c) && (c = (c << 6) | (t & 0x3f), ++length, ++p != limit) && (t = *p - 0x80) <= 0x3f) && // valid second-to-last trail byte (c = (c << 6) | t, ++length, ++p != limit) : // U+0080..U+07FF c >= 0xc2 && (c &= 0x1f, 1)) && // last trail byte (t = *p - 0x80) <= 0x3f) { c = (c << 6) | t; ++length; ++p; if constexpr (isMultiPass) { return {c, length, true, p0, p}; } else { return {c, length, true}; } } if constexpr (isMultiPass) { return {sub(), length, false, p0, p}; } else { return {sub(), length, false}; } } U_FORCE_INLINE static CodeUnits<CP32, UnitIter> decAndRead(UnitIter start, UnitIter &p) { // Very similar to U8_PREV_OR_FFFD(). UnitIter p0 = p; CP32 c = uint8_t(*--p); if (U8_IS_SINGLE(c)) { return {c, 1, true, p, p0}; } if (U8_IS_TRAIL(c) && p != start) { UnitIter p1 = p; uint8_t b1 = *--p1; if (U8_IS_LEAD(b1)) { if (b1 < 0xe0) { p = p1; c = ((b1 - 0xc0) << 6) | (c & 0x3f); return {c, 2, true, p, p0}; } else if (b1 < 0xf0 ? U8_IS_VALID_LEAD3_AND_T1(b1, c) : U8_IS_VALID_LEAD4_AND_T1(b1, c)) { // Truncated 3- or 4-byte sequence. p = p1; return {sub(), 2, false, p, p0}; } } else if (U8_IS_TRAIL(b1) && p1 != start) { // Extract the value bits from the last trail byte. c &= 0x3f; uint8_t b2 = *--p1; if (0xe0 <= b2 && b2 <= 0xf4) { if (b2 < 0xf0) { b2 &= 0xf; if (U8_IS_VALID_LEAD3_AND_T1(b2, b1)) { p = p1; c = (b2 << 12) | ((b1 & 0x3f) << 6) | c; return {c, 3, true, p, p0}; } } else if (U8_IS_VALID_LEAD4_AND_T1(b2, b1)) { // Truncated 4-byte sequence. p = p1; return {sub(), 3, false, p, p0}; } } else if (U8_IS_TRAIL(b2) && p1 != start) { uint8_t b3 = *--p1; if (0xf0 <= b3 && b3 <= 0xf4) { b3 &= 7; if (U8_IS_VALID_LEAD4_AND_T1(b3, b2)) { p = p1; c = (b3 << 18) | ((b2 & 0x3f) << 12) | ((b1 & 0x3f) << 6) | c; return {c, 4, true, p, p0}; } } } } } return {sub(), 1, false, p, p0}; } }; // UTF-16 template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter, typename LimitIter> class UTFImpl< CP32, behavior, UnitIter, LimitIter, std::enable_if_t<sizeof(typename prv::iter_value_t<UnitIter>) == 2>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: // Handle ill-formed UTF-16: One unpaired surrogate. U_FORCE_INLINE static CP32 sub(CP32 surrogate) { if constexpr (behavior == UTF_BEHAVIOR_NEGATIVE) { return U_SENTINEL; } else if constexpr (behavior == UTF_BEHAVIOR_FFFD) { return 0xfffd; } else { static_assert(behavior == UTF_BEHAVIOR_SURROGATE); return surrogate; } } U_FORCE_INLINE static void inc(UnitIter &p, const LimitIter &limit) { // Very similar to U16_FWD_1(). auto c = *p; ++p; if (U16_IS_LEAD(c) && p != limit && U16_IS_TRAIL(*p)) { ++p; } } U_FORCE_INLINE static void dec(UnitIter start, UnitIter &p) { // Very similar to U16_BACK_1(). UnitIter p1; if (U16_IS_TRAIL(*--p) && p != start && (p1 = p, U16_IS_LEAD(*--p1))) { p = p1; } } U_FORCE_INLINE static CodeUnits<CP32, UnitIter> readAndInc( UnitIter &p0, UnitIter &p, const LimitIter &limit) { constexpr bool isMultiPass = prv::forward_iterator<UnitIter>; // Very similar to U16_NEXT_OR_FFFD(). CP32 c = static_cast<CP32>(*p); ++p; if (!U16_IS_SURROGATE(c)) { if constexpr (isMultiPass) { return {c, 1, true, p0, p}; } else { return {c, 1, true}; } } else { uint16_t c2; if (U16_IS_SURROGATE_LEAD(c) && p != limit && U16_IS_TRAIL(c2 = *p)) { ++p; c = U16_GET_SUPPLEMENTARY(c, c2); if constexpr (isMultiPass) { return {c, 2, true, p0, p}; } else { return {c, 2, true}; } } else { if constexpr (isMultiPass) { return {sub(c), 1, false, p0, p}; } else { return {sub(c), 1, false}; } } } } U_FORCE_INLINE static CodeUnits<CP32, UnitIter> decAndRead(UnitIter start, UnitIter &p) { // Very similar to U16_PREV_OR_FFFD(). UnitIter p0 = p; CP32 c = static_cast<CP32>(*--p); if (!U16_IS_SURROGATE(c)) { return {c, 1, true, p, p0}; } else { UnitIter p1; uint16_t c2; if (U16_IS_SURROGATE_TRAIL(c) && p != start && (p1 = p, U16_IS_LEAD(c2 = *--p1))) { p = p1; c = U16_GET_SUPPLEMENTARY(c2, c); return {c, 2, true, p, p0}; } else { return {sub(c), 1, false, p, p0}; } } } }; // UTF-32: trivial, but still validating template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter, typename LimitIter> class UTFImpl< CP32, behavior, UnitIter, LimitIter, std::enable_if_t<sizeof(typename prv::iter_value_t<UnitIter>) == 4>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: // Handle ill-formed UTF-32 U_FORCE_INLINE static CP32 sub(bool forSurrogate, CP32 surrogate) { if constexpr (behavior == UTF_BEHAVIOR_NEGATIVE) { return U_SENTINEL; } else if constexpr (behavior == UTF_BEHAVIOR_FFFD) { return 0xfffd; } else { static_assert(behavior == UTF_BEHAVIOR_SURROGATE); return forSurrogate ? surrogate : 0xfffd; } } U_FORCE_INLINE static void inc(UnitIter &p, const LimitIter &/*limit*/) { ++p; } U_FORCE_INLINE static void dec(UnitIter /*start*/, UnitIter &p) { --p; } U_FORCE_INLINE static CodeUnits<CP32, UnitIter> readAndInc( UnitIter &p0, UnitIter &p, const LimitIter &/*limit*/) { constexpr bool isMultiPass = prv::forward_iterator<UnitIter>; uint32_t uc = *p; CP32 c = uc; ++p; if (uc < 0xd800 || (0xe000 <= uc && uc <= 0x10ffff)) { if constexpr (isMultiPass) { return {c, 1, true, p0, p}; } else { return {c, 1, true}; } } else { if constexpr (isMultiPass) { return {sub(uc < 0xe000, c), 1, false, p0, p}; } else { return {sub(uc < 0xe000, c), 1, false}; } } } U_FORCE_INLINE static CodeUnits<CP32, UnitIter> decAndRead(UnitIter /*start*/, UnitIter &p) { UnitIter p0 = p; uint32_t uc = *--p; CP32 c = uc; if (uc < 0xd800 || (0xe000 <= uc && uc <= 0x10ffff)) { return {c, 1, true, p, p0}; } else { return {sub(uc < 0xe000, c), 1, false, p, p0}; } } }; // Non-validating implementations ------------------------------------------ *** template<typename CP32, typename UnitIter, typename = void> class UnsafeUTFImpl; // UTF-8 template<typename CP32, typename UnitIter> class UnsafeUTFImpl< CP32, UnitIter, std::enable_if_t<sizeof(typename prv::iter_value_t<UnitIter>) == 1>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: U_FORCE_INLINE static void inc(UnitIter &p) { // Very similar to U8_FWD_1_UNSAFE(). uint8_t b = *p; std::advance(p, 1 + U8_COUNT_TRAIL_BYTES_UNSAFE(b)); } U_FORCE_INLINE static void dec(UnitIter &p) { // Very similar to U8_BACK_1_UNSAFE(). while (U8_IS_TRAIL(*--p)) {} } U_FORCE_INLINE static UnsafeCodeUnits<CP32, UnitIter> readAndInc(UnitIter &p0, UnitIter &p) { constexpr bool isMultiPass = prv::forward_iterator<UnitIter>; // Very similar to U8_NEXT_UNSAFE(). CP32 c = uint8_t(*p); ++p; if (U8_IS_SINGLE(c)) { if constexpr (isMultiPass) { return {c, 1, p0, p}; } else { return {c, 1}; } } else if (c < 0xe0) { c = ((c & 0x1f) << 6) | (*p & 0x3f); ++p; if constexpr (isMultiPass) { return {c, 2, p0, p}; } else { return {c, 2}; } } else if (c < 0xf0) { // No need for (c&0xf) because the upper bits are truncated // after <<12 in the cast to uint16_t. c = uint16_t(c << 12) | ((*p & 0x3f) << 6); ++p; c |= *p & 0x3f; ++p; if constexpr (isMultiPass) { return {c, 3, p0, p}; } else { return {c, 3}; } } else { c = ((c & 7) << 18) | ((*p & 0x3f) << 12); ++p; c |= (*p & 0x3f) << 6; ++p; c |= *p & 0x3f; ++p; if constexpr (isMultiPass) { return {c, 4, p0, p}; } else { return {c, 4}; } } } U_FORCE_INLINE static UnsafeCodeUnits<CP32, UnitIter> decAndRead(UnitIter &p) { // Very similar to U8_PREV_UNSAFE(). UnitIter p0 = p; CP32 c = uint8_t(*--p); if (U8_IS_SINGLE(c)) { return {c, 1, p, p0}; } // U8_IS_TRAIL(c) if well-formed c &= 0x3f; uint8_t count = 1; for (uint8_t shift = 6;;) { uint8_t b = *--p; if (b >= 0xc0) { U8_MASK_LEAD_BYTE(b, count); c |= uint32_t{b} << shift; break; } else { c |= (uint32_t{b} & 0x3f) << shift; ++count; shift += 6; } } ++count; return {c, count, p, p0}; } }; // UTF-16 template<typename CP32, typename UnitIter> class UnsafeUTFImpl< CP32, UnitIter, std::enable_if_t<sizeof(typename prv::iter_value_t<UnitIter>) == 2>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: U_FORCE_INLINE static void inc(UnitIter &p) { // Very similar to U16_FWD_1_UNSAFE(). auto c = *p; ++p; if (U16_IS_LEAD(c)) { ++p; } } U_FORCE_INLINE static void dec(UnitIter &p) { // Very similar to U16_BACK_1_UNSAFE(). if (U16_IS_TRAIL(*--p)) { --p; } } U_FORCE_INLINE static UnsafeCodeUnits<CP32, UnitIter> readAndInc(UnitIter &p0, UnitIter &p) { constexpr bool isMultiPass = prv::forward_iterator<UnitIter>; // Very similar to U16_NEXT_UNSAFE(). CP32 c = static_cast<CP32>(*p); ++p; if (!U16_IS_LEAD(c)) { if constexpr (isMultiPass) { return {c, 1, p0, p}; } else { return {c, 1}; } } else { uint16_t c2 = *p; ++p; c = U16_GET_SUPPLEMENTARY(c, c2); if constexpr (isMultiPass) { return {c, 2, p0, p}; } else { return {c, 2}; } } } U_FORCE_INLINE static UnsafeCodeUnits<CP32, UnitIter> decAndRead(UnitIter &p) { // Very similar to U16_PREV_UNSAFE(). UnitIter p0 = p; CP32 c = static_cast<CP32>(*--p); if (!U16_IS_TRAIL(c)) { return {c, 1, p, p0}; } else { uint16_t c2 = *--p; c = U16_GET_SUPPLEMENTARY(c2, c); return {c, 2, p, p0}; } } }; // UTF-32: trivial template<typename CP32, typename UnitIter> class UnsafeUTFImpl< CP32, UnitIter, std::enable_if_t<sizeof(typename prv::iter_value_t<UnitIter>) == 4>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: U_FORCE_INLINE static void inc(UnitIter &p) { ++p; } U_FORCE_INLINE static void dec(UnitIter &p) { --p; } U_FORCE_INLINE static UnsafeCodeUnits<CP32, UnitIter> readAndInc(UnitIter &p0, UnitIter &p) { constexpr bool isMultiPass = prv::forward_iterator<UnitIter>; CP32 c = *p; ++p; if constexpr (isMultiPass) { return {c, 1, p0, p}; } else { return {c, 1}; } } U_FORCE_INLINE static UnsafeCodeUnits<CP32, UnitIter> decAndRead(UnitIter &p) { UnitIter p0 = p; CP32 c = *--p; return {c, 1, p, p0}; } }; #endif // Validating iterators ---------------------------------------------------- *** /** * Validating iterator over the code points in a Unicode string. * * The UnitIter can be * an input_iterator, a forward_iterator, or a bidirectional_iterator (including a pointer). * The UTFIterator will have the corresponding iterator_category. * * Call utfIterator() to have the compiler deduce the UnitIter and LimitIter types. * * For reverse iteration, either use this iterator directly as in <code>*--iter</code> * or wrap it using std::make_reverse_iterator(iter). * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t; * should be signed if UTF_BEHAVIOR_NEGATIVE * @tparam behavior How to handle ill-formed Unicode strings * @tparam UnitIter An iterator (often a pointer) that returns a code unit type: * UTF-8: char or char8_t or uint8_t; * UTF-16: char16_t or uint16_t or (on Windows) wchar_t; * UTF-32: char32_t or UChar32=int32_t or (on Linux) wchar_t * @tparam LimitIter Either the same as UnitIter, or an iterator sentinel type. * @draft ICU 78 * @see utfIterator */ template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter, typename LimitIter = UnitIter, typename = void> class UTFIterator { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); using Impl = UTFImpl<CP32, behavior, UnitIter, LimitIter>; // Proxy type for operator->() (required by LegacyInputIterator) // so that we don't promise always returning CodeUnits. class Proxy { public: explicit Proxy(CodeUnits<CP32, UnitIter> &units) : units_(units) {} CodeUnits<CP32, UnitIter> &operator*() { return units_; } CodeUnits<CP32, UnitIter> *operator->() { return &units_; } private: CodeUnits<CP32, UnitIter> units_; }; public: /** C++ iterator boilerplate @internal */ using value_type = CodeUnits<CP32, UnitIter>; /** C++ iterator boilerplate @internal */ using reference = value_type; /** C++ iterator boilerplate @internal */ using pointer = Proxy; /** C++ iterator boilerplate @internal */ using difference_type = prv::iter_difference_t<UnitIter>; /** C++ iterator boilerplate @internal */ using iterator_category = std::conditional_t< prv::bidirectional_iterator<UnitIter>, std::bidirectional_iterator_tag, std::forward_iterator_tag>; /** * Constructor with start <= p < limit. * All of these iterators/pointers should be at code point boundaries. * Only enabled if UnitIter is a (multi-pass) forward_iterator or better. * * When using a code unit sentinel (UnitIter≠LimitIter), * then that sentinel also works as a sentinel for this code point iterator. * * @param start Start of the range * @param p Initial position inside the range * @param limit Limit (exclusive end) of the range * @draft ICU 78 */ U_FORCE_INLINE UTFIterator(UnitIter start, UnitIter p, LimitIter limit) : p_(p), start_(start), limit_(limit), units_(0, 0, false, p, p) {} /** * Constructor with start == p < limit. * All of these iterators/pointers should be at code point boundaries. * * When using a code unit sentinel (UnitIter≠LimitIter), * then that sentinel also works as a sentinel for this code point iterator. * * @param p Start of the range, and the initial position * @param limit Limit (exclusive end) of the range * @draft ICU 78 */ U_FORCE_INLINE UTFIterator(UnitIter p, LimitIter limit) : p_(p), start_(p), limit_(limit), units_(0, 0, false, p, p) {} /** * Constructs an iterator start or limit sentinel. * The iterator/pointer should be at a code point boundary. * Requires UnitIter to be copyable. * * When using a code unit sentinel (UnitIter≠LimitIter), * then that sentinel also works as a sentinel for this code point iterator. * * @param p Range start or limit * @draft ICU 78 */ U_FORCE_INLINE explicit UTFIterator(UnitIter p) : p_(p), start_(p), limit_(p), units_(0, 0, false, p, p) {} /** * Default constructor. Makes a non-functional iterator. * * @draft ICU 78 */ U_FORCE_INLINE UTFIterator() : p_{}, start_{}, limit_{}, units_(0, 0, false, p_, p_) {} /** Move constructor. @draft ICU 78 */ U_FORCE_INLINE UTFIterator(UTFIterator &&src) noexcept = default; /** Move assignment operator. @draft ICU 78 */ U_FORCE_INLINE UTFIterator &operator=(UTFIterator &&src) noexcept = default; /** Copy constructor. @draft ICU 78 */ U_FORCE_INLINE UTFIterator(const UTFIterator &other) = default; /** Copy assignment operator. @draft ICU 78 */ U_FORCE_INLINE UTFIterator &operator=(const UTFIterator &other) = default; /** * @param other Another iterator * @return true if this iterator is at the same position as the other one * @draft ICU 78 */ U_FORCE_INLINE bool operator==(const UTFIterator &other) const { return getLogicalPosition() == other.getLogicalPosition(); } /** * @param other Another iterator * @return true if this iterator is not at the same position as the other one * @draft ICU 78 */ U_FORCE_INLINE bool operator!=(const UTFIterator &other) const { return !operator==(other); } // Asymmetric equality & nonequality with a sentinel type. /** * @param iter A UTFIterator * @param s A unit iterator sentinel * @return true if the iterator’s position is equal to the sentinel * @draft ICU 78 */ template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator==(const UTFIterator &iter, const Sentinel &s) { return iter.getLogicalPosition() == s; } #if U_CPLUSPLUS_VERSION < 20 // C++17: Need to define all four combinations of == / != vs. parameter order. // Once we require C++20, we could remove all but the first == because // the compiler would generate the rest. /** * @param s A unit iterator sentinel * @param iter A UTFIterator * @return true if the iterator’s position is equal to the sentinel * @internal */ template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator==(const Sentinel &s, const UTFIterator &iter) { return iter.getLogicalPosition() == s; } /** * @param iter A UTFIterator * @param s A unit iterator sentinel * @return true if the iterator’s position is not equal to the sentinel * @internal */ template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator!=(const UTFIterator &iter, const Sentinel &s) { return !(iter == s); } /** * @param s A unit iterator sentinel * @param iter A UTFIterator * @return true if the iterator’s position is not equal to the sentinel * @internal */ template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator!=(const Sentinel &s, const UTFIterator &iter) { return !(iter == s); } #endif // C++17 /** * Decodes the code unit sequence at the current position. * * @return CodeUnits with the decoded code point etc. * @draft ICU 78 */ U_FORCE_INLINE CodeUnits<CP32, UnitIter> operator*() const { if (state_ == 0) { UnitIter p0 = p_; units_ = Impl::readAndInc(p0, p_, limit_); state_ = 1; } return units_; } /** * Decodes the code unit sequence at the current position. * Used like <code>iter->codePoint()</code> or <code>iter->stringView()</code> etc. * * @return CodeUnits with the decoded code point etc., wrapped into * an opaque proxy object so that <code>iter->codePoint()</code> etc. works. * @draft ICU 78 */ U_FORCE_INLINE Proxy operator->() const { if (state_ == 0) { UnitIter p0 = p_; units_ = Impl::readAndInc(p0, p_, limit_); state_ = 1; } return Proxy(units_); } /** * Pre-increment operator. * * @return this iterator * @draft ICU 78 */ U_FORCE_INLINE UTFIterator &operator++() { // pre-increment if (state_ > 0) { // operator*() called readAndInc() so p_ is already ahead. state_ = 0; } else if (state_ == 0) { Impl::inc(p_, limit_); } else /* state_ < 0 */ { // operator--() called decAndRead() so we know how far to skip. p_ = units_.end(); state_ = 0; } return *this; } /** * Post-increment operator. * * @return a copy of this iterator from before the increment. * If UnitIter is a single-pass input_iterator, then this function * returns an opaque proxy object so that <code>*iter++</code> still works. * @draft ICU 78 */ U_FORCE_INLINE UTFIterator operator++(int) { // post-increment if (state_ > 0) { // operator*() called readAndInc() so p_ is already ahead. UTFIterator result(*this); state_ = 0; return result; } else if (state_ == 0) { UnitIter p0 = p_; units_ = Impl::readAndInc(p0, p_, limit_); UTFIterator result(*this); result.state_ = 1; // keep this->state_ == 0 return result; } else /* state_ < 0 */ { UTFIterator result(*this); // operator--() called decAndRead() so we know how far to skip. p_ = units_.end(); state_ = 0; return result; } } /** * Pre-decrement operator. * Only enabled if UnitIter is a bidirectional_iterator (including a pointer). * * @return this iterator * @draft ICU 78 */ template<typename Iter = UnitIter> U_FORCE_INLINE std::enable_if_t<prv::bidirectional_iterator<Iter>, UTFIterator &> operator--() { // pre-decrement if (state_ > 0) { // operator*() called readAndInc() so p_ is ahead of the logical position. p_ = units_.begin(); } units_ = Impl::decAndRead(start_, p_); state_ = -1; return *this; } /** * Post-decrement operator. * Only enabled if UnitIter is a bidirectional_iterator (including a pointer). * * @return a copy of this iterator from before the decrement. * @draft ICU 78 */ template<typename Iter = UnitIter> U_FORCE_INLINE std::enable_if_t<prv::bidirectional_iterator<Iter>, UTFIterator> operator--(int) { // post-decrement UTFIterator result(*this); operator--(); return result; } private: friend class std::reverse_iterator<UTFIterator<CP32, behavior, UnitIter>>; U_FORCE_INLINE UnitIter getLogicalPosition() const { return state_ <= 0 ? p_ : units_.begin(); } // operator*() etc. are logically const. mutable UnitIter p_; // In a validating iterator, we need start_ & limit_ so that when we read a code point // (forward or backward) we can test if there are enough code units. UnitIter start_; LimitIter limit_; // Keep state so that we call readAndInc() only once for both operator*() and ++ // to make it easy for the compiler to optimize. mutable CodeUnits<CP32, UnitIter> units_; // >0: units_ = readAndInc(), p_ = units limit // which means that p_ is ahead of its logical position // 0: initial state // <0: units_ = decAndRead(), p_ = units start mutable int8_t state_ = 0; }; #ifndef U_IN_DOXYGEN // Partial template specialization for single-pass input iterator. template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter, typename LimitIter> class UTFIterator< CP32, behavior, UnitIter, LimitIter, std::enable_if_t<!prv::forward_iterator<UnitIter>>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); using Impl = UTFImpl<CP32, behavior, UnitIter, LimitIter>; // Proxy type for post-increment return value, to make *iter++ work. // Also for operator->() (required by LegacyInputIterator) // so that we don't promise always returning CodeUnits. class Proxy { public: explicit Proxy(CodeUnits<CP32, UnitIter> &units) : units_(units) {} CodeUnits<CP32, UnitIter> &operator*() { return units_; } CodeUnits<CP32, UnitIter> *operator->() { return &units_; } private: CodeUnits<CP32, UnitIter> units_; }; public: using value_type = CodeUnits<CP32, UnitIter>; using reference = value_type; using pointer = Proxy; using difference_type = prv::iter_difference_t<UnitIter>; using iterator_category = std::input_iterator_tag; U_FORCE_INLINE UTFIterator(UnitIter p, LimitIter limit) : p_(std::move(p)), limit_(std::move(limit)) {} // Constructs an iterator start or limit sentinel. // Requires p to be copyable. U_FORCE_INLINE explicit UTFIterator(UnitIter p) : p_(std::move(p)), limit_(p_) {} U_FORCE_INLINE UTFIterator(UTFIterator &&src) noexcept = default; U_FORCE_INLINE UTFIterator &operator=(UTFIterator &&src) noexcept = default; U_FORCE_INLINE UTFIterator(const UTFIterator &other) = default; U_FORCE_INLINE UTFIterator &operator=(const UTFIterator &other) = default; U_FORCE_INLINE bool operator==(const UTFIterator &other) const { return p_ == other.p_ && ahead_ == other.ahead_; // Strictly speaking, we should check if the logical position is the same. // However, we cannot advance, or do arithmetic with, a single-pass UnitIter. } U_FORCE_INLINE bool operator!=(const UTFIterator &other) const { return !operator==(other); } template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator==(const UTFIterator &iter, const Sentinel &s) { return !iter.ahead_ && iter.p_ == s; } #if U_CPLUSPLUS_VERSION < 20 template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator==(const Sentinel &s, const UTFIterator &iter) { return !iter.ahead_ && iter.p_ == s; } template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator!=(const UTFIterator &iter, const Sentinel &s) { return !(iter == s); } template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator!=(const Sentinel &s, const UTFIterator &iter) { return !(iter == s); } #endif // C++17 U_FORCE_INLINE CodeUnits<CP32, UnitIter> operator*() const { if (!ahead_) { units_ = Impl::readAndInc(p_, p_, limit_); ahead_ = true; } return units_; } U_FORCE_INLINE Proxy operator->() const { if (!ahead_) { units_ = Impl::readAndInc(p_, p_, limit_); ahead_ = true; } return Proxy(units_); } U_FORCE_INLINE UTFIterator &operator++() { // pre-increment if (ahead_) { // operator*() called readAndInc() so p_ is already ahead. ahead_ = false; } else { Impl::inc(p_, limit_); } return *this; } U_FORCE_INLINE Proxy operator++(int) { // post-increment if (ahead_) { // operator*() called readAndInc() so p_ is already ahead. ahead_ = false; } else { units_ = Impl::readAndInc(p_, p_, limit_); // keep this->ahead_ == false } return Proxy(units_); } private: // operator*() etc. are logically const. mutable UnitIter p_; // In a validating iterator, we need limit_ so that when we read a code point // we can test if there are enough code units. LimitIter limit_; // Keep state so that we call readAndInc() only once for both operator*() and ++ // so that we can use a single-pass input iterator for UnitIter. mutable CodeUnits<CP32, UnitIter> units_ = {0, 0, false}; // true: units_ = readAndInc(), p_ = units limit // which means that p_ is ahead of its logical position // false: initial state mutable bool ahead_ = false; }; #endif // U_IN_DOXYGEN } // namespace U_HEADER_ONLY_NAMESPACE #ifndef U_IN_DOXYGEN // Bespoke specialization of reverse_iterator. // The default implementation implements reverse operator*() and ++ in a way // that does most of the same work twice for reading variable-length sequences. template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter> class std::reverse_iterator<U_HEADER_ONLY_NAMESPACE::UTFIterator<CP32, behavior, UnitIter>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); using Impl = U_HEADER_ONLY_NAMESPACE::UTFImpl<CP32, behavior, UnitIter>; using CodeUnits_ = U_HEADER_ONLY_NAMESPACE::CodeUnits<CP32, UnitIter>; // Proxy type for operator->() (required by LegacyInputIterator) // so that we don't promise always returning CodeUnits. class Proxy { public: explicit Proxy(CodeUnits_ units) : units_(units) {} CodeUnits_ &operator*() { return units_; } CodeUnits_ *operator->() { return &units_; } private: CodeUnits_ units_; }; public: using value_type = CodeUnits_; using reference = value_type; using pointer = Proxy; using difference_type = U_HEADER_ONLY_NAMESPACE::prv::iter_difference_t<UnitIter>; using iterator_category = std::bidirectional_iterator_tag; U_FORCE_INLINE explicit reverse_iterator(U_HEADER_ONLY_NAMESPACE::UTFIterator<CP32, behavior, UnitIter> iter) : p_(iter.getLogicalPosition()), start_(iter.start_), limit_(iter.limit_), units_(0, 0, false, p_, p_) {} U_FORCE_INLINE reverse_iterator() : p_{}, start_{}, limit_{}, units_(0, 0, false, p_, p_) {} U_FORCE_INLINE reverse_iterator(reverse_iterator &&src) noexcept = default; U_FORCE_INLINE reverse_iterator &operator=(reverse_iterator &&src) noexcept = default; U_FORCE_INLINE reverse_iterator(const reverse_iterator &other) = default; U_FORCE_INLINE reverse_iterator &operator=(const reverse_iterator &other) = default; U_FORCE_INLINE bool operator==(const reverse_iterator &other) const { return getLogicalPosition() == other.getLogicalPosition(); } U_FORCE_INLINE bool operator!=(const reverse_iterator &other) const { return !operator==(other); } U_FORCE_INLINE CodeUnits_ operator*() const { if (state_ == 0) { units_ = Impl::decAndRead(start_, p_); state_ = -1; } return units_; } U_FORCE_INLINE Proxy operator->() const { if (state_ == 0) { units_ = Impl::decAndRead(start_, p_); state_ = -1; } return Proxy(units_); } U_FORCE_INLINE reverse_iterator &operator++() { // pre-increment if (state_ < 0) { // operator*() called decAndRead() so p_ is already behind. state_ = 0; } else if (state_ == 0) { Impl::dec(start_, p_); } else /* state_ > 0 */ { // operator--() called readAndInc() so we know how far to skip. p_ = units_.begin(); state_ = 0; } return *this; } U_FORCE_INLINE reverse_iterator operator++(int) { // post-increment if (state_ < 0) { // operator*() called decAndRead() so p_ is already behind. reverse_iterator result(*this); state_ = 0; return result; } else if (state_ == 0) { units_ = Impl::decAndRead(start_, p_); reverse_iterator result(*this); result.state_ = -1; // keep this->state_ == 0 return result; } else /* state_ > 0 */ { reverse_iterator result(*this); // operator--() called readAndInc() so we know how far to skip. p_ = units_.begin(); state_ = 0; return result; } } U_FORCE_INLINE reverse_iterator &operator--() { // pre-decrement if (state_ < 0) { // operator*() called decAndRead() so p_ is behind the logical position. p_ = units_.end(); } UnitIter p0 = p_; units_ = Impl::readAndInc(p0, p_, limit_); state_ = 1; return *this; } U_FORCE_INLINE reverse_iterator operator--(int) { // post-decrement reverse_iterator result(*this); operator--(); return result; } private: U_FORCE_INLINE UnitIter getLogicalPosition() const { return state_ >= 0 ? p_ : units_.end(); } // operator*() etc. are logically const. mutable UnitIter p_; // In a validating iterator, we need start_ & limit_ so that when we read a code point // (forward or backward) we can test if there are enough code units. UnitIter start_; UnitIter limit_; // Keep state so that we call decAndRead() only once for both operator*() and ++ // to make it easy for the compiler to optimize. mutable CodeUnits_ units_; // >0: units_ = readAndInc(), p_ = units limit // 0: initial state // <0: units_ = decAndRead(), p_ = units start // which means that p_ is behind its logical position mutable int8_t state_ = 0; }; #endif // U_IN_DOXYGEN namespace U_HEADER_ONLY_NAMESPACE { /** * UTFIterator factory function for start <= p < limit. * Deduces the UnitIter and LimitIter template parameters from the inputs. * Only enabled if UnitIter is a (multi-pass) forward_iterator or better. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t * @tparam behavior How to handle ill-formed Unicode strings * @tparam UnitIter Can usually be omitted/deduced: * An iterator (often a pointer) that returns a code unit type: * UTF-8: char or char8_t or uint8_t; * UTF-16: char16_t or uint16_t or (on Windows) wchar_t; * UTF-32: char32_t or UChar32=int32_t or (on Linux) wchar_t * @tparam LimitIter Either the same as UnitIter, or an iterator sentinel type. * @param start start code unit iterator * @param p current-position code unit iterator * @param limit limit (exclusive-end) code unit iterator. * When using a code unit sentinel (UnitIter≠LimitIter), * then that sentinel also works as a sentinel for the code point iterator. * @return a UTFIterator<CP32, behavior, UnitIter> * for the given code unit iterators or character pointers * @draft ICU 78 */ template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter, typename LimitIter = UnitIter> auto utfIterator(UnitIter start, UnitIter p, LimitIter limit) { return UTFIterator<CP32, behavior, UnitIter, LimitIter>( std::move(start), std::move(p), std::move(limit)); } /** * UTFIterator factory function for start = p < limit. * Deduces the UnitIter and LimitIter template parameters from the inputs. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t * @tparam behavior How to handle ill-formed Unicode strings * @tparam UnitIter Can usually be omitted/deduced: * An iterator (often a pointer) that returns a code unit type: * UTF-8: char or char8_t or uint8_t; * UTF-16: char16_t or uint16_t or (on Windows) wchar_t; * UTF-32: char32_t or UChar32=int32_t or (on Linux) wchar_t * @tparam LimitIter Either the same as UnitIter, or an iterator sentinel type. * @param p start and current-position code unit iterator * @param limit limit (exclusive-end) code unit iterator. * When using a code unit sentinel (UnitIter≠LimitIter), * then that sentinel also works as a sentinel for the code point iterator. * @return a UTFIterator<CP32, behavior, UnitIter> * for the given code unit iterators or character pointers * @draft ICU 78 */ template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter, typename LimitIter = UnitIter> auto utfIterator(UnitIter p, LimitIter limit) { return UTFIterator<CP32, behavior, UnitIter, LimitIter>( std::move(p), std::move(limit)); } // Note: We should only enable the following factory function for a copyable UnitIter. // In C++17, we would have to partially specialize with enable_if_t testing for forward_iterator, // but a function template partial specialization is not allowed. // In C++20, we might be able to require the std::copyable concept. /** * UTFIterator factory function for a start or limit sentinel. * Deduces the UnitIter template parameter from the input. * Requires UnitIter to be copyable. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t * @tparam behavior How to handle ill-formed Unicode strings * @tparam UnitIter Can usually be omitted/deduced: * An iterator (often a pointer) that returns a code unit type: * UTF-8: char or char8_t or uint8_t; * UTF-16: char16_t or uint16_t or (on Windows) wchar_t; * UTF-32: char32_t or UChar32=int32_t or (on Linux) wchar_t * @param p code unit iterator. * When using a code unit sentinel, * then that sentinel also works as a sentinel for the code point iterator. * @return a UTFIterator<CP32, behavior, UnitIter> * for the given code unit iterator or character pointer * @draft ICU 78 */ template<typename CP32, UTFIllFormedBehavior behavior, typename UnitIter> auto utfIterator(UnitIter p) { return UTFIterator<CP32, behavior, UnitIter>(std::move(p)); } /** * A C++ "range" for validating iteration over all of the code points of a code unit range. * * Call utfStringCodePoints() to have the compiler deduce the Range type. * * UTFStringCodePoints is conditionally borrowed; that is, if Range is a borrowed range * so is UTFStringCodePoints<CP32, behavior, Range>. * Note that when given a range r that is an lvalue and is not a view, utfStringCodePoints(r) uses a * ref_view of r as the Range type, which is a borrowed range. * In practice, this means that given a container variable r, the iterators of utfStringCodePoints(r) can * be used as long as iterators on r are valid, without having to keep utfStringCodePoints(r) around. * For instance: * \code * std::u8string s = "𒇧𒇧"; * // it outlives utfStringCodePoints<char32_t>(s). * auto it = utfStringCodePoints<char32_t>(s).begin(); * ++it; * char32_t second_code_point = it->codePoint(); // OK. * \endcode * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t; * should be signed if UTF_BEHAVIOR_NEGATIVE * @tparam behavior How to handle ill-formed Unicode strings * @tparam Range A C++ "range" of Unicode UTF-8/16/32 code units * @draft ICU 78 * @see utfStringCodePoints */ template<typename CP32, UTFIllFormedBehavior behavior, typename Range> class UTFStringCodePoints { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: /** * Constructs an empty C++ "range" object. * @draft ICU 78 */ UTFStringCodePoints() = default; /** * Constructs a C++ "range" object over the code points in the string. * @param unitRange input range * @draft ICU 78 */ template<typename R = Range, typename = std::enable_if_t<!std::is_reference_v<R>>> explicit UTFStringCodePoints(Range unitRange) : unitRange(std::move(unitRange)) {} /** * Constructs a C++ "range" object over the code points in the string, * keeping a reference to the code unit range. This overload is used by * utfStringCodePoints in C++17; in C+20, a ref_view is used instead (via * views::all). * @param unitRange input range * @draft ICU 78 */ template<typename R = Range, typename = std::enable_if_t<std::is_reference_v<R>>, typename = void> explicit UTFStringCodePoints(Range unitRange) : unitRange(unitRange) {} /** Copy constructor. @draft ICU 78 */ UTFStringCodePoints(const UTFStringCodePoints &other) = default; /** Copy assignment operator. @draft ICU 78 */ UTFStringCodePoints &operator=(const UTFStringCodePoints &other) = default; /** * @return the range start iterator * @draft ICU 78 */ auto begin() { return utfIterator<CP32, behavior>(unitRange.begin(), unitRange.end()); } /** * @return the range start iterator * @draft ICU 78 */ template<typename R = Range, typename = std::enable_if_t<prv::range<const R>>> auto begin() const { return utfIterator<CP32, behavior>(unitRange.begin(), unitRange.end()); } /** * @return the range limit (exclusive end) iterator * @draft ICU 78 */ auto end() { using UnitIter = decltype(unitRange.begin()); using LimitIter = decltype(unitRange.end()); if constexpr (!std::is_same_v<UnitIter, LimitIter>) { // Return the code unit sentinel. return unitRange.end(); } else if constexpr (prv::bidirectional_iterator<UnitIter>) { return utfIterator<CP32, behavior>(unitRange.begin(), unitRange.end(), unitRange.end()); } else { // The input iterator specialization has no three-argument constructor. return utfIterator<CP32, behavior>(unitRange.end(), unitRange.end()); } } /** * @return the range limit (exclusive end) iterator * @draft ICU 78 */ template<typename R = Range, typename = std::enable_if_t<prv::range<const R>>> auto end() const { using UnitIter = decltype(unitRange.begin()); using LimitIter = decltype(unitRange.end()); if constexpr (!std::is_same_v<UnitIter, LimitIter>) { // Return the code unit sentinel. return unitRange.end(); } else if constexpr (prv::bidirectional_iterator<UnitIter>) { return utfIterator<CP32, behavior>(unitRange.begin(), unitRange.end(), unitRange.end()); } else { // The input iterator specialization has no three-argument constructor. return utfIterator<CP32, behavior>(unitRange.end(), unitRange.end()); } } /** * @return std::reverse_iterator(end()) * @draft ICU 78 */ auto rbegin() const { return std::make_reverse_iterator(end()); } /** * @return std::reverse_iterator(begin()) * @draft ICU 78 */ auto rend() const { return std::make_reverse_iterator(begin()); } private: Range unitRange; }; /** @internal */ template<typename CP32, UTFIllFormedBehavior behavior> struct UTFStringCodePointsAdaptor #if U_CPLUSPLUS_VERSION >= 23 && __cpp_lib_ranges >= 2022'02 && \ __cpp_lib_bind_back >= 2022'02 // http://wg21.link/P2387R3. : std::ranges::range_adaptor_closure<UTFStringCodePointsAdaptor<CP32, behavior>> #endif { /** @internal */ template<typename Range> auto operator()(Range &&unitRange) const { #if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 2021'10 // We need https://wg21.link/P2415R2. return UTFStringCodePoints<CP32, behavior, std::ranges::views::all_t<Range>>( std::forward<Range>(unitRange)); #else if constexpr (prv::is_basic_string_view_v<std::decay_t<Range>>) { // Take basic_string_view by copy, not by reference. In C++20 this is handled by // all_t<Range>, which is Range if Range is a view. return UTFStringCodePoints<CP32, behavior, std::decay_t<Range>>( std::forward<Range>(unitRange)); } else { return UTFStringCodePoints<CP32, behavior, Range>(std::forward<Range>(unitRange)); } #endif } }; /** * Range adaptor function object returning a UTFStringCodePoints object that represents a "range" of code * points in a code unit range, which validates while decoding. * Deduces the Range template parameter from the input, taking into account the value category: the * code units will be referenced if possible, and moved if necessary. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t; * should be signed if UTF_BEHAVIOR_NEGATIVE * @tparam behavior How to handle ill-formed Unicode strings * @tparam Range A C++ "range" of Unicode UTF-8/16/32 code units * @param unitRange input range * @return a UTFStringCodePoints<CP32, behavior, Range> for the given unitRange * @draft ICU 78 */ template<typename CP32, UTFIllFormedBehavior behavior> constexpr UTFStringCodePointsAdaptor<CP32, behavior> utfStringCodePoints; // Non-validating iterators ------------------------------------------------ *** /** * Non-validating iterator over the code points in a Unicode string. * The string must be well-formed. * * The UnitIter can be * an input_iterator, a forward_iterator, or a bidirectional_iterator (including a pointer). * The UTFIterator will have the corresponding iterator_category. * * Call unsafeUTFIterator() to have the compiler deduce the UnitIter type. * * For reverse iteration, either use this iterator directly as in <code>*--iter</code> * or wrap it using std::make_reverse_iterator(iter). * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t * @tparam UnitIter An iterator (often a pointer) that returns a code unit type: * UTF-8: char or char8_t or uint8_t; * UTF-16: char16_t or uint16_t or (on Windows) wchar_t; * UTF-32: char32_t or UChar32=int32_t or (on Linux) wchar_t * @draft ICU 78 * @see unsafeUTFIterator */ template<typename CP32, typename UnitIter, typename = void> class UnsafeUTFIterator { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); using Impl = UnsafeUTFImpl<CP32, UnitIter>; // Proxy type for operator->() (required by LegacyInputIterator) // so that we don't promise always returning UnsafeCodeUnits. class Proxy { public: explicit Proxy(UnsafeCodeUnits<CP32, UnitIter> &units) : units_(units) {} UnsafeCodeUnits<CP32, UnitIter> &operator*() { return units_; } UnsafeCodeUnits<CP32, UnitIter> *operator->() { return &units_; } private: UnsafeCodeUnits<CP32, UnitIter> units_; }; public: /** C++ iterator boilerplate @internal */ using value_type = UnsafeCodeUnits<CP32, UnitIter>; /** C++ iterator boilerplate @internal */ using reference = value_type; /** C++ iterator boilerplate @internal */ using pointer = Proxy; /** C++ iterator boilerplate @internal */ using difference_type = prv::iter_difference_t<UnitIter>; /** C++ iterator boilerplate @internal */ using iterator_category = std::conditional_t< prv::bidirectional_iterator<UnitIter>, std::bidirectional_iterator_tag, std::forward_iterator_tag>; /** * Constructor; the iterator/pointer should be at a code point boundary. * * When using a code unit sentinel, * then that sentinel also works as a sentinel for this code point iterator. * * @param p Initial position inside the range, or a range sentinel * @draft ICU 78 */ U_FORCE_INLINE explicit UnsafeUTFIterator(UnitIter p) : p_(p), units_(0, 0, p, p) {} /** * Default constructor. Makes a non-functional iterator. * * @draft ICU 78 */ U_FORCE_INLINE UnsafeUTFIterator() : p_{}, units_(0, 0, p_, p_) {} /** Move constructor. @draft ICU 78 */ U_FORCE_INLINE UnsafeUTFIterator(UnsafeUTFIterator &&src) noexcept = default; /** Move assignment operator. @draft ICU 78 */ U_FORCE_INLINE UnsafeUTFIterator &operator=(UnsafeUTFIterator &&src) noexcept = default; /** Copy constructor. @draft ICU 78 */ U_FORCE_INLINE UnsafeUTFIterator(const UnsafeUTFIterator &other) = default; /** Copy assignment operator. @draft ICU 78 */ U_FORCE_INLINE UnsafeUTFIterator &operator=(const UnsafeUTFIterator &other) = default; /** * @param other Another iterator * @return true if this iterator is at the same position as the other one * @draft ICU 78 */ U_FORCE_INLINE bool operator==(const UnsafeUTFIterator &other) const { return getLogicalPosition() == other.getLogicalPosition(); } /** * @param other Another iterator * @return true if this iterator is not at the same position as the other one * @draft ICU 78 */ U_FORCE_INLINE bool operator!=(const UnsafeUTFIterator &other) const { return !operator==(other); } /** * @param iter An UnsafeUTFIterator * @param s A unit iterator sentinel * @return true if the iterator’s position is equal to the sentinel * @draft ICU 78 */ template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UnsafeUTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator==(const UnsafeUTFIterator &iter, const Sentinel &s) { return iter.getLogicalPosition() == s; } #if U_CPLUSPLUS_VERSION < 20 /** * @param s A unit iterator sentinel * @param iter An UnsafeUTFIterator * @return true if the iterator’s position is equal to the sentinel * @internal */ template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UnsafeUTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator==(const Sentinel &s, const UnsafeUTFIterator &iter) { return iter.getLogicalPosition() == s; } /** * @param iter An UnsafeUTFIterator * @param s A unit iterator sentinel * @return true if the iterator’s position is not equal to the sentinel * @internal */ template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UnsafeUTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator!=(const UnsafeUTFIterator &iter, const Sentinel &s) { return !(iter == s); } /** * @param s A unit iterator sentinel * @param iter An UnsafeUTFIterator * @return true if the iterator’s position is not equal to the sentinel * @internal */ template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UnsafeUTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator!=(const Sentinel &s, const UnsafeUTFIterator &iter) { return !(iter == s); } #endif // C++17 /** * Decodes the code unit sequence at the current position. * * @return CodeUnits with the decoded code point etc. * @draft ICU 78 */ U_FORCE_INLINE UnsafeCodeUnits<CP32, UnitIter> operator*() const { if (state_ == 0) { UnitIter p0 = p_; units_ = Impl::readAndInc(p0, p_); state_ = 1; } return units_; } /** * Decodes the code unit sequence at the current position. * Used like <code>iter->codePoint()</code> or <code>iter->stringView()</code> etc. * * @return CodeUnits with the decoded code point etc., wrapped into * an opaque proxy object so that <code>iter->codePoint()</code> etc. works. * @draft ICU 78 */ U_FORCE_INLINE Proxy operator->() const { if (state_ == 0) { UnitIter p0 = p_; units_ = Impl::readAndInc(p0, p_); state_ = 1; } return Proxy(units_); } /** * Pre-increment operator. * * @return this iterator * @draft ICU 78 */ U_FORCE_INLINE UnsafeUTFIterator &operator++() { // pre-increment if (state_ > 0) { // operator*() called readAndInc() so p_ is already ahead. state_ = 0; } else if (state_ == 0) { Impl::inc(p_); } else /* state_ < 0 */ { // operator--() called decAndRead() so we know how far to skip. p_ = units_.end(); state_ = 0; } return *this; } /** * Post-increment operator. * * @return a copy of this iterator from before the increment. * If UnitIter is a single-pass input_iterator, then this function * returns an opaque proxy object so that <code>*iter++</code> still works. * @draft ICU 78 */ U_FORCE_INLINE UnsafeUTFIterator operator++(int) { // post-increment if (state_ > 0) { // operator*() called readAndInc() so p_ is already ahead. UnsafeUTFIterator result(*this); state_ = 0; return result; } else if (state_ == 0) { UnitIter p0 = p_; units_ = Impl::readAndInc(p0, p_); UnsafeUTFIterator result(*this); result.state_ = 1; // keep this->state_ == 0 return result; } else /* state_ < 0 */ { UnsafeUTFIterator result(*this); // operator--() called decAndRead() so we know how far to skip. p_ = units_.end(); state_ = 0; return result; } } /** * Pre-decrement operator. * Only enabled if UnitIter is a bidirectional_iterator (including a pointer). * * @return this iterator * @draft ICU 78 */ template<typename Iter = UnitIter> U_FORCE_INLINE std::enable_if_t<prv::bidirectional_iterator<Iter>, UnsafeUTFIterator &> operator--() { // pre-decrement if (state_ > 0) { // operator*() called readAndInc() so p_ is ahead of the logical position. p_ = units_.begin(); } units_ = Impl::decAndRead(p_); state_ = -1; return *this; } /** * Post-decrement operator. * Only enabled if UnitIter is a bidirectional_iterator (including a pointer). * * @return a copy of this iterator from before the decrement. * @draft ICU 78 */ template<typename Iter = UnitIter> U_FORCE_INLINE std::enable_if_t<prv::bidirectional_iterator<Iter>, UnsafeUTFIterator> operator--(int) { // post-decrement UnsafeUTFIterator result(*this); operator--(); return result; } private: friend class std::reverse_iterator<UnsafeUTFIterator<CP32, UnitIter>>; U_FORCE_INLINE UnitIter getLogicalPosition() const { return state_ <= 0 ? p_ : units_.begin(); } // operator*() etc. are logically const. mutable UnitIter p_; // Keep state so that we call readAndInc() only once for both operator*() and ++ // to make it easy for the compiler to optimize. mutable UnsafeCodeUnits<CP32, UnitIter> units_; // >0: units_ = readAndInc(), p_ = units limit // which means that p_ is ahead of its logical position // 0: initial state // <0: units_ = decAndRead(), p_ = units start mutable int8_t state_ = 0; }; #ifndef U_IN_DOXYGEN // Partial template specialization for single-pass input iterator. template<typename CP32, typename UnitIter> class UnsafeUTFIterator< CP32, UnitIter, std::enable_if_t<!prv::forward_iterator<UnitIter>>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); using Impl = UnsafeUTFImpl<CP32, UnitIter>; // Proxy type for post-increment return value, to make *iter++ work. // Also for operator->() (required by LegacyInputIterator) // so that we don't promise always returning UnsafeCodeUnits. class Proxy { public: explicit Proxy(UnsafeCodeUnits<CP32, UnitIter> &units) : units_(units) {} UnsafeCodeUnits<CP32, UnitIter> &operator*() { return units_; } UnsafeCodeUnits<CP32, UnitIter> *operator->() { return &units_; } private: UnsafeCodeUnits<CP32, UnitIter> units_; }; public: using value_type = UnsafeCodeUnits<CP32, UnitIter>; using reference = value_type; using pointer = Proxy; using difference_type = prv::iter_difference_t<UnitIter>; using iterator_category = std::input_iterator_tag; U_FORCE_INLINE explicit UnsafeUTFIterator(UnitIter p) : p_(std::move(p)) {} U_FORCE_INLINE UnsafeUTFIterator(UnsafeUTFIterator &&src) noexcept = default; U_FORCE_INLINE UnsafeUTFIterator &operator=(UnsafeUTFIterator &&src) noexcept = default; U_FORCE_INLINE UnsafeUTFIterator(const UnsafeUTFIterator &other) = default; U_FORCE_INLINE UnsafeUTFIterator &operator=(const UnsafeUTFIterator &other) = default; U_FORCE_INLINE bool operator==(const UnsafeUTFIterator &other) const { return p_ == other.p_ && ahead_ == other.ahead_; // Strictly speaking, we should check if the logical position is the same. // However, we cannot advance, or do arithmetic with, a single-pass UnitIter. } U_FORCE_INLINE bool operator!=(const UnsafeUTFIterator &other) const { return !operator==(other); } template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UnsafeUTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator==(const UnsafeUTFIterator &iter, const Sentinel &s) { return !iter.ahead_ && iter.p_ == s; } #if U_CPLUSPLUS_VERSION < 20 template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UnsafeUTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator==(const Sentinel &s, const UnsafeUTFIterator &iter) { return !iter.ahead_ && iter.p_ == s; } template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UnsafeUTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator!=(const UnsafeUTFIterator &iter, const Sentinel &s) { return !(iter == s); } template<typename Sentinel> U_FORCE_INLINE friend std::enable_if_t< !std::is_same_v<Sentinel, UnsafeUTFIterator> && !std::is_same_v<Sentinel, UnitIter>, bool> operator!=(const Sentinel &s, const UnsafeUTFIterator &iter) { return !(iter == s); } #endif // C++17 U_FORCE_INLINE UnsafeCodeUnits<CP32, UnitIter> operator*() const { if (!ahead_) { units_ = Impl::readAndInc(p_, p_); ahead_ = true; } return units_; } U_FORCE_INLINE Proxy operator->() const { if (!ahead_) { units_ = Impl::readAndInc(p_, p_); ahead_ = true; } return Proxy(units_); } U_FORCE_INLINE UnsafeUTFIterator &operator++() { // pre-increment if (ahead_) { // operator*() called readAndInc() so p_ is already ahead. ahead_ = false; } else { Impl::inc(p_); } return *this; } U_FORCE_INLINE Proxy operator++(int) { // post-increment if (ahead_) { // operator*() called readAndInc() so p_ is already ahead. ahead_ = false; } else { units_ = Impl::readAndInc(p_, p_); // keep this->ahead_ == false } return Proxy(units_); } private: // operator*() etc. are logically const. mutable UnitIter p_; // Keep state so that we call readAndInc() only once for both operator*() and ++ // so that we can use a single-pass input iterator for UnitIter. mutable UnsafeCodeUnits<CP32, UnitIter> units_ = {0, 0}; // true: units_ = readAndInc(), p_ = units limit // which means that p_ is ahead of its logical position // false: initial state mutable bool ahead_ = false; }; #endif // U_IN_DOXYGEN } // namespace U_HEADER_ONLY_NAMESPACE #ifndef U_IN_DOXYGEN // Bespoke specialization of reverse_iterator. // The default implementation implements reverse operator*() and ++ in a way // that does most of the same work twice for reading variable-length sequences. template<typename CP32, typename UnitIter> class std::reverse_iterator<U_HEADER_ONLY_NAMESPACE::UnsafeUTFIterator<CP32, UnitIter>> { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); using Impl = U_HEADER_ONLY_NAMESPACE::UnsafeUTFImpl<CP32, UnitIter>; using UnsafeCodeUnits_ = U_HEADER_ONLY_NAMESPACE::UnsafeCodeUnits<CP32, UnitIter>; // Proxy type for operator->() (required by LegacyInputIterator) // so that we don't promise always returning UnsafeCodeUnits. class Proxy { public: explicit Proxy(UnsafeCodeUnits_ units) : units_(units) {} UnsafeCodeUnits_ &operator*() { return units_; } UnsafeCodeUnits_ *operator->() { return &units_; } private: UnsafeCodeUnits_ units_; }; public: using value_type = UnsafeCodeUnits_; using reference = value_type; using pointer = Proxy; using difference_type = U_HEADER_ONLY_NAMESPACE::prv::iter_difference_t<UnitIter>; using iterator_category = std::bidirectional_iterator_tag; U_FORCE_INLINE explicit reverse_iterator(U_HEADER_ONLY_NAMESPACE::UnsafeUTFIterator<CP32, UnitIter> iter) : p_(iter.getLogicalPosition()), units_(0, 0, p_, p_) {} U_FORCE_INLINE reverse_iterator() : p_{}, units_(0, 0, p_, p_) {} U_FORCE_INLINE reverse_iterator(reverse_iterator &&src) noexcept = default; U_FORCE_INLINE reverse_iterator &operator=(reverse_iterator &&src) noexcept = default; U_FORCE_INLINE reverse_iterator(const reverse_iterator &other) = default; U_FORCE_INLINE reverse_iterator &operator=(const reverse_iterator &other) = default; U_FORCE_INLINE bool operator==(const reverse_iterator &other) const { return getLogicalPosition() == other.getLogicalPosition(); } U_FORCE_INLINE bool operator!=(const reverse_iterator &other) const { return !operator==(other); } U_FORCE_INLINE UnsafeCodeUnits_ operator*() const { if (state_ == 0) { units_ = Impl::decAndRead(p_); state_ = -1; } return units_; } U_FORCE_INLINE Proxy operator->() const { if (state_ == 0) { units_ = Impl::decAndRead(p_); state_ = -1; } return Proxy(units_); } U_FORCE_INLINE reverse_iterator &operator++() { // pre-increment if (state_ < 0) { // operator*() called decAndRead() so p_ is already behind. state_ = 0; } else if (state_ == 0) { Impl::dec(p_); } else /* state_ > 0 */ { // operator--() called readAndInc() so we know how far to skip. p_ = units_.begin(); state_ = 0; } return *this; } U_FORCE_INLINE reverse_iterator operator++(int) { // post-increment if (state_ < 0) { // operator*() called decAndRead() so p_ is already behind. reverse_iterator result(*this); state_ = 0; return result; } else if (state_ == 0) { units_ = Impl::decAndRead(p_); reverse_iterator result(*this); result.state_ = -1; // keep this->state_ == 0 return result; } else /* state_ > 0 */ { reverse_iterator result(*this); // operator--() called readAndInc() so we know how far to skip. p_ = units_.begin(); state_ = 0; return result; } } U_FORCE_INLINE reverse_iterator &operator--() { // pre-decrement if (state_ < 0) { // operator*() called decAndRead() so p_ is behind the logical position. p_ = units_.end(); } UnitIter p0 = p_; units_ = Impl::readAndInc(p0, p_); state_ = 1; return *this; } U_FORCE_INLINE reverse_iterator operator--(int) { // post-decrement reverse_iterator result(*this); operator--(); return result; } private: U_FORCE_INLINE UnitIter getLogicalPosition() const { return state_ >= 0 ? p_ : units_.end(); } // operator*() etc. are logically const. mutable UnitIter p_; // Keep state so that we call decAndRead() only once for both operator*() and ++ // to make it easy for the compiler to optimize. mutable UnsafeCodeUnits_ units_; // >0: units_ = readAndInc(), p_ = units limit // 0: initial state // <0: units_ = decAndRead(), p_ = units start // which means that p_ is behind its logical position mutable int8_t state_ = 0; }; #endif // U_IN_DOXYGEN namespace U_HEADER_ONLY_NAMESPACE { /** * UnsafeUTFIterator factory function. * Deduces the UnitIter template parameter from the input. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t * @tparam UnitIter Can usually be omitted/deduced: * An iterator (often a pointer) that returns a code unit type: * UTF-8: char or char8_t or uint8_t; * UTF-16: char16_t or uint16_t or (on Windows) wchar_t; * UTF-32: char32_t or UChar32=int32_t or (on Linux) wchar_t * @param iter code unit iterator * @return an UnsafeUTFIterator<CP32, UnitIter> * for the given code unit iterator or character pointer * @draft ICU 78 */ template<typename CP32, typename UnitIter> auto unsafeUTFIterator(UnitIter iter) { return UnsafeUTFIterator<CP32, UnitIter>(std::move(iter)); } /** * A C++ "range" for non-validating iteration over all of the code points of a code unit range. * The string must be well-formed. * * Call unsafeUTFStringCodePoints() to have the compiler deduce the Range type. * * UnsafeUTFStringCodePoints is conditionally borrowed; that is, if Range is a borrowed range * so is UnsafeUTFStringCodePoints<CP32, behavior, Range>. * Note that when given a range r that is an lvalue and is not a view, unsafeUTFStringCodePoints(r) uses * a ref_view of r as the Range type, which is a borrowed range. * In practice, this means that given a container variable r, the iterators of * unsafeUTFStringCodePoints(r) can be used as long as iterators on r are valid, without having to keep * unsafeUTFStringCodePoints(r) around. * For instance: * \code * std::u8string s = "𒇧𒇧"; * // it outlives unsafeUTFStringCodePoints<char32_t>(s). * auto it = unsafeUTFStringCodePoints<char32_t>(s).begin(); * ++it; * char32_t second_code_point = it->codePoint(); // OK. * \endcode * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t * @tparam Range A C++ "range" of Unicode UTF-8/16/32 code units * @draft ICU 78 * @see unsafeUTFStringCodePoints */ template<typename CP32, typename Range> class UnsafeUTFStringCodePoints { static_assert(sizeof(CP32) == 4, "CP32 must be a 32-bit type to hold a code point"); public: /** * Constructs an empty C++ "range" object. * @draft ICU 78 */ UnsafeUTFStringCodePoints() = default; /** * Constructs a C++ "range" object over the code points in the string. * @param unitRange input range * @draft ICU 78 */ template<typename R = Range, typename = std::enable_if_t<!std::is_reference_v<R>>> explicit UnsafeUTFStringCodePoints(Range unitRange) : unitRange(std::move(unitRange)) {} /** * Constructs a C++ "range" object over the code points in the string, * keeping a reference to the code unit range. This overload is used by * utfStringCodePoints in C++17; in C++20, a ref_view is used instead (via * views::all). * @param unitRange input range * @draft ICU 78 */ template<typename R = Range, typename = std::enable_if_t<std::is_reference_v<R>>, typename = void> explicit UnsafeUTFStringCodePoints(Range unitRange) : unitRange(unitRange) {} /** Copy constructor. @draft ICU 78 */ UnsafeUTFStringCodePoints(const UnsafeUTFStringCodePoints &other) = default; /** Copy assignment operator. @draft ICU 78 */ UnsafeUTFStringCodePoints &operator=(const UnsafeUTFStringCodePoints &other) = default; /** * @return the range start iterator * @draft ICU 78 */ auto begin() { return unsafeUTFIterator<CP32>(unitRange.begin()); } /** * @return the range start iterator * @draft ICU 78 */ template<typename R = Range, typename = std::enable_if_t<prv::range<const R>>> auto begin() const { return unsafeUTFIterator<CP32>(unitRange.begin()); } /** * @return the range limit (exclusive end) iterator * @draft ICU 78 */ auto end() { using UnitIter = decltype(unitRange.begin()); using LimitIter = decltype(unitRange.end()); if constexpr (!std::is_same_v<UnitIter, LimitIter>) { // Return the code unit sentinel. return unitRange.end(); } else { return unsafeUTFIterator<CP32>(unitRange.end()); } } /** * @return the range limit (exclusive end) iterator * @draft ICU 78 */ template<typename R = Range, typename = std::enable_if_t<prv::range<const R>>> auto end() const { using UnitIter = decltype(unitRange.begin()); using LimitIter = decltype(unitRange.end()); if constexpr (!std::is_same_v<UnitIter, LimitIter>) { // Return the code unit sentinel. return unitRange.end(); } else { return unsafeUTFIterator<CP32>(unitRange.end()); } } /** * @return std::reverse_iterator(end()) * @draft ICU 78 */ auto rbegin() const { return std::make_reverse_iterator(end()); } /** * @return std::reverse_iterator(begin()) * @draft ICU 78 */ auto rend() const { return std::make_reverse_iterator(begin()); } private: Range unitRange; }; /** @internal */ template<typename CP32> struct UnsafeUTFStringCodePointsAdaptor #if U_CPLUSPLUS_VERSION >= 23 && __cpp_lib_ranges >= 2022'02 && \ __cpp_lib_bind_back >= 2022'02 // http://wg21.link/P2387R3. : std::ranges::range_adaptor_closure<UnsafeUTFStringCodePointsAdaptor<CP32>> #endif { /** @internal */ template<typename Range> auto operator()(Range &&unitRange) const { #if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 2021'10 // We need https://wg21.link/P2415R2. return UnsafeUTFStringCodePoints<CP32, std::ranges::views::all_t<Range>>(std::forward<Range>(unitRange)); #else if constexpr (prv::is_basic_string_view_v<std::decay_t<Range>>) { // Take basic_string_view by copy, not by reference. In C++20 this is handled by // all_t<Range>, which is Range if Range is a view. return UnsafeUTFStringCodePoints<CP32, std::decay_t<Range>>(std::forward<Range>(unitRange)); } else { return UnsafeUTFStringCodePoints<CP32, Range>(std::forward<Range>(unitRange)); } #endif } }; /** * Range adaptor function object returning an UnsafeUTFStringCodePoints object that represents a * "range" of code points in a code unit range. The string must be well-formed. * Deduces the Range template parameter from the input, taking into account the value category: the * code units will be referenced if possible, and moved if necessary. * * @tparam CP32 Code point type: UChar32 (=int32_t) or char32_t or uint32_t * @tparam Range A C++ "range" of Unicode UTF-8/16/32 code units * @param unitRange input range * @return an UnsafeUTFStringCodePoints<CP32, Range> for the given unitRange * @draft ICU 78 */ template<typename CP32> constexpr UnsafeUTFStringCodePointsAdaptor<CP32> unsafeUTFStringCodePoints; } // namespace U_HEADER_ONLY_NAMESPACE #if defined(__cpp_lib_ranges) template <typename CP32, UTFIllFormedBehavior behavior, typename Range> constexpr bool std::ranges::enable_borrowed_range< U_HEADER_ONLY_NAMESPACE::UTFStringCodePoints<CP32, behavior, Range>> = std::ranges::enable_borrowed_range<Range>; template <typename CP32, typename Range> constexpr bool std::ranges::enable_borrowed_range< U_HEADER_ONLY_NAMESPACE::UnsafeUTFStringCodePoints<CP32, Range>> = std::ranges::enable_borrowed_range<Range>; #endif #endif // U_HIDE_DRAFT_API #endif // U_SHOW_CPLUSPLUS_API || U_SHOW_CPLUSPLUS_HEADER_API #endif // __UTFITERATOR_H__

N4m3	5!z3	L45t M0d!f!3d	0wn3r / Gr0up	P3Rm!55!0n5	0pt!0n5
..	--	October 18 2024 10:43:37	root / root	0755

alphaindex.h	26.433 KB	April 09 2026 09:07:42	root / root	0644
appendable.h	8.54 KB	April 09 2026 09:07:41	root / root	0644
basictz.h	9.988 KB	April 09 2026 09:07:42	root / root	0644
brkiter.h	28.52 KB	April 09 2026 09:07:41	root / root	0644
bytestream.h	11.79 KB	April 09 2026 09:07:41	root / root	0644
bytestrie.h	20.827 KB	April 09 2026 09:07:41	root / root	0644
bytestriebuilder.h	7.437 KB	April 09 2026 09:07:41	root / root	0644
calendar.h	110.47 KB	April 09 2026 09:07:42	root / root	0644
caniter.h	7.473 KB	April 09 2026 09:07:41	root / root	0644
casemap.h	25.417 KB	April 09 2026 09:07:41	root / root	0644
char16ptr.h	10.786 KB	April 09 2026 09:07:41	root / root	0644
chariter.h	23.791 KB	April 09 2026 09:07:41	root / root	0644
choicfmt.h	23.987 KB	April 09 2026 09:07:42	root / root	0644
coleitr.h	13.783 KB	April 09 2026 09:07:42	root / root	0644
coll.h	59.5 KB	April 09 2026 09:07:42	root / root	0644
compactdecimalformat.h	6.876 KB	April 09 2026 09:07:42	root / root	0644
curramt.h	3.668 KB	April 09 2026 09:07:42	root / root	0644
currpinf.h	7.304 KB	April 09 2026 09:07:42	root / root	0644
currunit.h	4.019 KB	April 09 2026 09:07:42	root / root	0644
datefmt.h	41.293 KB	April 09 2026 09:07:42	root / root	0644
dbbi.h	1.194 KB	April 09 2026 09:07:41	root / root	0644
dcfmtsym.h	21.271 KB	April 09 2026 09:07:42	root / root	0644
decimfmt.h	87.453 KB	April 09 2026 09:07:42	root / root	0644
displayoptions.h	7.082 KB	April 09 2026 09:07:42	root / root	0644
docmain.h	7.655 KB	April 09 2026 09:07:41	root / root	0644
dtfmtsym.h	41.036 KB	April 09 2026 09:07:42	root / root	0644
dtintrv.h	3.839 KB	April 09 2026 09:07:41	root / root	0644
dtitvfmt.h	49.203 KB	April 09 2026 09:07:42	root / root	0644
dtitvinf.h	18.536 KB	April 09 2026 09:07:42	root / root	0644
dtptngen.h	29.28 KB	April 09 2026 09:07:42	root / root	0644
dtrule.h	8.656 KB	April 09 2026 09:07:42	root / root	0644
edits.h	20.738 KB	April 09 2026 09:07:41	root / root	0644
enumset.h	2.08 KB	April 09 2026 09:07:41	root / root	0644
errorcode.h	4.84 KB	April 09 2026 09:07:41	root / root	0644
fieldpos.h	8.688 KB	April 09 2026 09:07:42	root / root	0644
filteredbrk.h	5.372 KB	April 09 2026 09:07:41	root / root	0644
fmtable.h	24.36 KB	April 09 2026 09:07:42	root / root	0644
format.h	12.776 KB	April 09 2026 09:07:42	root / root	0644
formattednumber.h	6.253 KB	April 09 2026 09:07:42	root / root	0644
formattedvalue.h	9.753 KB	April 09 2026 09:07:42	root / root	0644
fpositer.h	3.03 KB	April 09 2026 09:07:42	root / root	0644
gender.h	3.346 KB	April 09 2026 09:07:42	root / root	0644
gregocal.h	30.049 KB	April 09 2026 09:07:42	root / root	0644
icudataver.h	1.024 KB	April 09 2026 09:07:41	root / root	0644
icuplug.h	12.102 KB	April 09 2026 09:07:41	root / root	0644
idna.h	12.929 KB	April 09 2026 09:07:41	root / root	0644
listformatter.h	8.593 KB	April 09 2026 09:07:42	root / root	0644
localebuilder.h	11.09 KB	April 09 2026 09:07:41	root / root	0644
localematcher.h	26.859 KB	April 09 2026 09:07:41	root / root	0644
localpointer.h	19.517 KB	April 09 2026 09:07:41	root / root	0644
locdspnm.h	7.121 KB	April 09 2026 09:07:41	root / root	0644
locid.h	53.979 KB	April 09 2026 09:07:41	root / root	0644
measfmt.h	11.414 KB	April 09 2026 09:07:42	root / root	0644
measunit.h	133.121 KB	April 09 2026 09:07:42	root / root	0644
measure.h	4.627 KB	April 09 2026 09:07:42	root / root	0644
messageformat2.h	21.588 KB	April 09 2026 09:07:42	root / root	0644
messageformat2_arguments.h	3.844 KB	April 09 2026 09:07:42	root / root	0644
messageformat2_data_model.h	96.61 KB	April 09 2026 09:07:42	root / root	0644
messageformat2_data_model_names.h	0.766 KB	April 09 2026 09:07:42	root / root	0644
messageformat2_formattable.h	39.365 KB	April 09 2026 09:07:42	root / root	0644
messageformat2_function_registry.h	18.07 KB	April 09 2026 09:07:42	root / root	0644
messagepattern.h	33.789 KB	April 09 2026 09:07:41	root / root	0644
msgfmt.h	44.938 KB	April 09 2026 09:07:42	root / root	0644
normalizer2.h	34.684 KB	April 09 2026 09:07:41	root / root	0644
normlzr.h	30.793 KB	April 09 2026 09:07:41	root / root	0644
nounit.h	2.24 KB	April 09 2026 09:07:42	root / root	0644
numberformatter.h	90.721 KB	April 09 2026 09:07:42	root / root	0644
numberrangeformatter.h	25.678 KB	April 09 2026 09:07:42	root / root	0644
numfmt.h	50.155 KB	April 09 2026 09:07:42	root / root	0644
numsys.h	7.224 KB	April 09 2026 09:07:42	root / root	0644
parseerr.h	3.081 KB	April 09 2026 09:07:41	root / root	0644
parsepos.h	5.561 KB	April 09 2026 09:07:41	root / root	0644
platform.h	27.188 KB	April 09 2026 09:07:41	root / root	0644
plurfmt.h	25.462 KB	April 09 2026 09:07:42	root / root	0644
plurrule.h	20.633 KB	April 09 2026 09:07:42	root / root	0644
ptypes.h	2.159 KB	April 09 2026 09:07:41	root / root	0644
putil.h	6.319 KB	April 09 2026 09:07:41	root / root	0644
rbbi.h	31.726 KB	April 09 2026 09:07:41	root / root	0644
rbnf.h	57.192 KB	April 09 2026 09:07:42	root / root	0644
rbtz.h	15.745 KB	April 09 2026 09:07:42	root / root	0644
regex.h	83.835 KB	April 09 2026 09:07:42	root / root	0644
region.h	9.196 KB	April 09 2026 09:07:42	root / root	0644
reldatefmt.h	22.687 KB	April 09 2026 09:07:42	root / root	0644
rep.h	9.377 KB	April 09 2026 09:07:41	root / root	0644
resbund.h	18.021 KB	April 09 2026 09:07:41	root / root	0644
schriter.h	6.087 KB	April 09 2026 09:07:41	root / root	0644
scientificnumberformatter.h	6.443 KB	April 09 2026 09:07:42	root / root	0644
search.h	22.208 KB	April 09 2026 09:07:42	root / root	0644
selfmt.h	14.347 KB	April 09 2026 09:07:42	root / root	0644
simpleformatter.h	12.596 KB	April 09 2026 09:07:41	root / root	0644
simplenumberformatter.h	8.87 KB	April 09 2026 09:07:42	root / root	0644
simpletz.h	45.621 KB	April 09 2026 09:07:42	root / root	0644
smpdtfmt.h	57.573 KB	April 09 2026 09:07:42	root / root	0644
sortkey.h	11.129 KB	April 09 2026 09:07:42	root / root	0644
std_string.h	1.051 KB	April 09 2026 09:07:41	root / root	0644
strenum.h	9.963 KB	April 09 2026 09:07:41	root / root	0644
stringoptions.h	5.787 KB	April 09 2026 09:07:41	root / root	0644
stringpiece.h	10.285 KB	April 09 2026 09:07:41	root / root	0644
stringtriebuilder.h	15.529 KB	April 09 2026 09:07:41	root / root	0644
stsearch.h	21.432 KB	April 09 2026 09:07:42	root / root	0644
symtable.h	4.283 KB	April 09 2026 09:07:41	root / root	0644
tblcoll.h	38.786 KB	April 09 2026 09:07:42	root / root	0644
timezone.h	45.588 KB	April 09 2026 09:07:42	root / root	0644
tmunit.h	3.371 KB	April 09 2026 09:07:42	root / root	0644
tmutamt.h	4.901 KB	April 09 2026 09:07:42	root / root	0644
tmutfmt.h	7.416 KB	April 09 2026 09:07:42	root / root	0644
translit.h	65.809 KB	April 09 2026 09:07:42	root / root	0644
tzfmt.h	44.757 KB	April 09 2026 09:07:42	root / root	0644
tznames.h	16.85 KB	April 09 2026 09:07:42	root / root	0644
tzrule.h	34.811 KB	April 09 2026 09:07:42	root / root	0644
tztrans.h	6.111 KB	April 09 2026 09:07:42	root / root	0644
ubidi.h	89.608 KB	April 09 2026 09:07:41	root / root	0644
ubiditransform.h	12.705 KB	April 09 2026 09:07:41	root / root	0644
ubrk.h	24.435 KB	April 09 2026 09:07:41	root / root	0644
ucal.h	63.954 KB	April 09 2026 09:07:42	root / root	0644
ucasemap.h	15.267 KB	April 09 2026 09:07:41	root / root	0644
ucat.h	5.35 KB	April 09 2026 09:07:41	root / root	0644
uchar.h	152.327 KB	April 09 2026 09:07:41	root / root	0644
ucharstrie.h	22.586 KB	April 09 2026 09:07:41	root / root	0644
ucharstriebuilder.h	7.483 KB	April 09 2026 09:07:41	root / root	0644
uchriter.h	13.24 KB	April 09 2026 09:07:41	root / root	0644
uclean.h	11.206 KB	April 09 2026 09:07:41	root / root	0644
ucnv.h	83.343 KB	April 09 2026 09:07:41	root / root	0644
ucnv_cb.h	6.584 KB	April 09 2026 09:07:41	root / root	0644
ucnv_err.h	20.982 KB	April 09 2026 09:07:41	root / root	0644
ucnvsel.h	6.241 KB	April 09 2026 09:07:41	root / root	0644
ucol.h	67.353 KB	April 09 2026 09:07:42	root / root	0644
ucoleitr.h	9.82 KB	April 09 2026 09:07:42	root / root	0644
uconfig.h	12.558 KB	April 09 2026 09:07:41	root / root	0644
ucpmap.h	5.541 KB	April 09 2026 09:07:41	root / root	0644
ucptrie.h	22.515 KB	April 09 2026 09:07:41	root / root	0644
ucsdet.h	14.69 KB	April 09 2026 09:07:42	root / root	0644
ucurr.h	16.721 KB	April 09 2026 09:07:41	root / root	0644
udat.h	62.655 KB	April 09 2026 09:07:42	root / root	0644
udata.h	15.631 KB	April 09 2026 09:07:41	root / root	0644
udateintervalformat.h	11.932 KB	April 09 2026 09:07:42	root / root	0644
udatpg.h	30.128 KB	April 09 2026 09:07:42	root / root	0644
udisplaycontext.h	5.941 KB	April 09 2026 09:07:41	root / root	0644
udisplayoptions.h	8.86 KB	April 09 2026 09:07:42	root / root	0644
uenum.h	7.794 KB	April 09 2026 09:07:41	root / root	0644
ufieldpositer.h	4.407 KB	April 09 2026 09:07:42	root / root	0644
uformattable.h	10.97 KB	April 09 2026 09:07:42	root / root	0644
uformattednumber.h	8.087 KB	April 09 2026 09:07:42	root / root	0644
uformattedvalue.h	12.255 KB	April 09 2026 09:07:42	root / root	0644
ugender.h	2.057 KB	April 09 2026 09:07:42	root / root	0644
uidna.h	34.117 KB	April 09 2026 09:07:41	root / root	0644
uiter.h	22.753 KB	April 09 2026 09:07:41	root / root	0644
uldnames.h	10.481 KB	April 09 2026 09:07:41	root / root	0644
ulistformatter.h	10.784 KB	April 09 2026 09:07:42	root / root	0644
uloc.h	55.377 KB	April 09 2026 09:07:41	root / root	0644
ulocale.h	6.314 KB	April 09 2026 09:07:41	root / root	0644
ulocbuilder.h	16.693 KB	April 09 2026 09:07:41	root / root	0644
ulocdata.h	11.297 KB	April 09 2026 09:07:42	root / root	0644
umachine.h	15.249 KB	April 09 2026 09:07:41	root / root	0644
umisc.h	1.34 KB	April 09 2026 09:07:41	root / root	0644
umsg.h	24.25 KB	April 09 2026 09:07:42	root / root	0644
umutablecptrie.h	8.302 KB	April 09 2026 09:07:41	root / root	0644
unifilt.h	3.995 KB	April 09 2026 09:07:41	root / root	0644
unifunct.h	4.046 KB	April 09 2026 09:07:41	root / root	0644
unimatch.h	6.098 KB	April 09 2026 09:07:41	root / root	0644
unirepl.h	3.383 KB	April 09 2026 09:07:42	root / root	0644
uniset.h	70.176 KB	April 09 2026 09:07:41	root / root	0644
unistr.h	184.511 KB	April 09 2026 09:07:41	root / root	0644
unorm.h	20.549 KB	April 09 2026 09:07:41	root / root	0644
unorm2.h	25.662 KB	April 09 2026 09:07:41	root / root	0644
unum.h	55.162 KB	April 09 2026 09:07:42	root / root	0644
unumberformatter.h	19.681 KB	April 09 2026 09:07:42	root / root	0644
unumberoptions.h	5.234 KB	April 09 2026 09:07:42	root / root	0644
unumberrangeformatter.h	15.354 KB	April 09 2026 09:07:42	root / root	0644
unumsys.h	7.256 KB	April 09 2026 09:07:42	root / root	0644
uobject.h	10.604 KB	April 09 2026 09:07:41	root / root	0644
upluralrules.h	8.786 KB	April 09 2026 09:07:42	root / root	0644
uregex.h	71.991 KB	April 09 2026 09:07:42	root / root	0644
uregion.h	9.812 KB	April 09 2026 09:07:42	root / root	0644
ureldatefmt.h	16.979 KB	April 09 2026 09:07:42	root / root	0644
urename.h	142.221 KB	April 09 2026 09:07:41	root / root	0644
urep.h	5.378 KB	April 09 2026 09:07:41	root / root	0644
ures.h	36.646 KB	April 09 2026 09:07:41	root / root	0644
uscript.h	28.948 KB	April 09 2026 09:07:41	root / root	0644
usearch.h	39.212 KB	April 09 2026 09:07:42	root / root	0644
uset.h	63.032 KB	April 09 2026 09:07:41	root / root	0644
usetiter.h	9.625 KB	April 09 2026 09:07:41	root / root	0644
ushape.h	17.998 KB	April 09 2026 09:07:41	root / root	0644
usimplenumberformatter.h	7.306 KB	April 09 2026 09:07:42	root / root	0644
uspoof.h	80.001 KB	April 09 2026 09:07:43	root / root	0644
usprep.h	8.186 KB	April 09 2026 09:07:41	root / root	0644
ustdio.h	38.576 KB	April 09 2026 09:07:43	root / root	0644
ustream.h	1.889 KB	April 09 2026 09:07:43	root / root	0644
ustring.h	72.158 KB	April 09 2026 09:07:41	root / root	0644
ustringtrie.h	3.148 KB	April 09 2026 09:07:41	root / root	0644
utext.h	58.101 KB	April 09 2026 09:07:41	root / root	0644
utf.h	8.652 KB	April 09 2026 09:07:41	root / root	0644
utf16.h	23.35 KB	April 09 2026 09:07:41	root / root	0644
utf32.h	0.745 KB	April 09 2026 09:07:41	root / root	0644
utf8.h	31.652 KB	April 09 2026 09:07:41	root / root	0644
utf_old.h	45.854 KB	April 09 2026 09:07:41	root / root	0644
utfiterator.h	95.018 KB	April 09 2026 09:07:41	root / root	0644
utfstring.h	4.894 KB	April 09 2026 09:07:41	root / root	0644
utmscale.h	13.776 KB	April 09 2026 09:07:43	root / root	0644
utrace.h	17.183 KB	April 09 2026 09:07:41	root / root	0644
utrans.h	25.544 KB	April 09 2026 09:07:43	root / root	0644
utypes.h	36.729 KB	April 09 2026 09:07:41	root / root	0644
uvernum.h	6.328 KB	April 09 2026 09:07:41	root / root	0644
uversion.h	8.215 KB	April 09 2026 09:07:41	root / root	0644
vtzone.h	20.676 KB	April 09 2026 09:07:43	root / root	0644

$.' ",#(7),01444'9=82<.342ÿÛ C 2!!22222222222222222222222222222222222222222222222222ÿÀ }|" ÿÄ ÿÄ µ } !1AQa "q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúÿÄ ÿÄ µ w !1AQ aq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿÚ ? ÷HR÷j¹ûA <Ìƒ.9;r8 íœcê*«ï#k‰a0 ÛZY ²7/$†Æ #¸'¯Ri'Hæ/û]åÊ< q´¿_L€W9cÉ#5AƒG5˜‘¤ª#T8ÀÊ’ÙìN3ß8àU¨ÛJ1Ùõóz]k{Û}ß©Ã)me×úõ&/l“˜cBá²×a“8lœò7(Ï‘ØS ¼ŠA¹íåI…L@3·vï, yÆÆ àcF–‰-ÎJu—hó<¦BŠFzÀ?tãúguR‹u#‡{~?Ú•£=n¾qo~öôüô¸¾³$õüÑ»jò]Mä¦ >ÎÈ[¢à–?) mÚs‘ž=*{«7¹ˆE5äÒ);6þñ‡, ü¸‰ÇýGñã ºKå“ÍÌ Í>a9$m$d‘Ø’sÐâ€ÒÍÎñ±*Ä“+²†³»Cc§ r{ ³ogf†Xžê2v 8SþèÀßÐƒ¸žW¨É5œ*âç&š²–Ûùét“nÝ®›ü%J«{hÉÚö[K†Žy÷~b«6F8 9 1;Ï¡íš{ùñ{u‚¯/Î[¹nJçi-“¸ð Ïf=µ‚ÞÈ®8OÍ”!c H%N@<ŽqÈlu"š…xHm®ä<*ó7•…Á Á#‡|‘Ó¦õq“êífÛüŸ•oNÚ{ËFý;– ŠÙ–!½Òq–‹væRqŒ®?„ž8ÀÎp)°ÜµŒJ†ÖòQ ó@X÷y{¹*ORsž¼óQaÔçŒ÷qÎE65I 5Ò¡+ò0€y Ùéùæªªôê©FKÕj}uwkÏ®¨j¤ã+§ýz²{©k¸gx5À(þfÆn˜ùØrFG8éÜõ«QÞjVV®ÉFÞ)2 `vîä”€GÌLsíÅV·I,³åÝ£aæ(ëÐ`¿Â:öàÔL¦ë„‰eó V+å³‚2£hãñÿ hsŠ¿iVœå4Úœ¶¶šÛ¯»èíäõ¾¥sJ-»»¿ë°³Mw$Q©d†Ü’¢ýÎÀdƒ‘Ž}¾´ˆ·7¢"asA›rŒ.v@ ÞÇj”Y´%Š–·–5\Ü²õåË2Hã×°*¾d_(˜»#'<ŒîØ1œuþ!ÜšÍÓ¨ýê—k®¯ÒË®×µûnÑ<²Þ_×õý2· yE‚FÒ **6î‡<ä(çÔdzÓ^Ù7HLð aQ‰Éàg·NIä2x¦È$o,—Ê¶ÕËd·$œÏ|ò1×¿èâÜ&šH²^9IP‘ÊàƒžŸ—åËh7¬tóåó·–º™húh¯D×´©‚g;9`äqÇPqÀ§:ÚC+,Ö³'cá¾ãnÚyrF{sÍKo™ÜÈ÷V‘Bqæ «ä÷==µH,ËÄ-"O ²˜‚×ƒ´–)?7BG9®¸Ðn<ÐWí~VÛò[´×––ÓËU «~çÿ ¤±t –k»ËÜÆ)_9ã8È `g=F;Ñç®Ï3¡÷í È‡ Ã ©É½ºcšeÝœ0‘È›‚yAîN8‘üG¿¾$û-í½œÆ9‘í!ˆ9F9çxëøž*o_žIÆÖZò¥ÓºVùöõ¿w¦Ýˆæ•´ÓYÄ®³ËV£êƒæõç?áNòîn.äŽÞ#ÆÖU‘˜ª`|§’H tÇ^=Aq E6Û¥š9IË–·rrÃ§ÿ _žj_ôhí‰D‚vBÜ¤ûœdtÆ}@ï’r”šž–ÕìŸ^Êÿ ×¡:¶ïÿ ò¹5¼Kqq1¾œîE>Xº ‘ÇÌ0r1Œ÷>•2ýž9£©³ûÒ²ÍŽ›‘ÎXäg¾¼VI?¹*‡äÈ-“‚N=3ÐsÏ¿¾*{™ªù›·4ahKG9êG{©üM]+]¼«Ë¸ Š—mcÏ±‚y=yç¶:)T…JÉ>d»$Ýôùnµz2”¢åÍ ¬ ¼ÑËsnŠÜ«ˆS¨;yÛÊŽ½=px¥ŠÒæM°=ÕÌi*±€ Þ² 1‘Ž=qŸj†ãQ¾yæ»ŠA–,2œcR;ãwáÅfÊÈìT©#æä`žø jšøŒ59¾H·¯VÕÕûëçÚÝyµA9Ó‹Ñ?Çúþºš—QÇ ÔvòßNqù«¼!ç‚¹äç¿C»=:Öš#m#bYã†ð¦/(œúŒtè Qž CÍÂÉ¶ž ÇVB ž2ONOZrA óAÇf^3–÷ÉéÁëÇç\ó«·äƒütéß_-Ï¦nJ[/Ì|2Ï#[Ù–!’,Oä‘Ç|sVâ±Ô/|´–Iœ˜î$àc®Fwt+Ûø¿zÏTšyLPZ>#a· ^r7d\u ©¢•âÈ3 83…ˆDTœ’@rOéÐW†ÁP”S”Ü£ó[‰ÚßŽÚ;éÕNŒW“kîüÊ ¨"VHlí×>ZÜ nwÝÏ ›¶ìqÎ×·Õel¿,³4Æ4`;/I'pxaœÔñ¼";vixUu˜’¸YÆ1×#®:Ž T–ñÒ[{Kwi mð·šÙ99Î cÏ#23É«Ÿ-Þ3ii¶©»ÒW·•×~Ôí£Óúô- »yY Ýå™’8¤|c-ó‚<–þ S#3Ì‰q¡mÜI"«€d cqf üç× #5PÜý®XüØWtîßy¹?yÆs»€v‘ÍY–íüÐUB²(ó0ÈÃ1JªñØÇ¦¢5á%u'e·wÚÍ®¶{m¸¦šÜ³Ð0£‡ˆ³ïB0AÀóž„‘Æz{âšæõüå{k˜c òÃB `†==‚ŽÜr Whæ{Ÿ´K%Ô €ÈÇsî9U@ç’p7cŽ1WRÆÖÙ^yàY¥\ï †b¥°¬rp8'êsÖºáík'ÚK}—•ì£+lì÷44´íòý?«Ö÷0¤I"Ú³.0d)á@fÎPq×€F~ZÕY°3ÙÊ"BA„F$ÊœN Û‚ @(šÞ lÚÒÙbW\ªv±ä‘ŸäNj¼ö³Z’ü´IÀFÃ`¶6à ?! NxÇÒ©Ò†Oª²½’·ŸM¶{êºjÚqŒ©®èþ ‰ ’&yL%?yÕÃ”®$•Ï\p4—:…À—u½ä‘°Ýæ$aCß”$ñŸoÄÙ>TÓù¦ƒÂKÆÅÉ@¹'yè{žÝ4ÍKûcíCì vŽ…y?]Ol©Ê|Íê¾Þ_;üÿ Ï¡Rçånÿ rÔ’[m²»˜¡Ž4ùDŽ›Ë) $’XxËëšY8¹i•†Á!‘þpJ•V^0 Œ±õèi²Å²en%·„†8eeù²Yˆ,S†=?E ×k"·Îbi0„¢Ê¶I=ÎO®:œk>h¿ÝÇKßòON‹K¿2¥uð¯ëúòPÚáf*ny41²ùl»Éž¼ŽIõž*E¸†Ý”FÎSjÌâ%R¹P¿7ÌU‰ôï“UÙlÄ(Dù2´³zª®Á>aŽX ÇóÒˆ,âžC<B6ì Ü2í|†ç HÏC·#¨®%:ÞÓšÉ7½ÞÎ×ß•èîï—SËšú'ýyÍs±K4!Ì„0óŒ{£Øs÷‚çzŒð¹ã5æHC+Û=¼Í}ygn0c|œðOAô9îkÔ®£ŽÕf™¦»R#copÛICžÃ©þ :ñ^eñ©ðe·”’´ø‘¦f å— # <ò3ïÖ»ðŸ×©Æ¤•Ó½»ï®ß‹·ôµ4ù'ý_ðLO‚òF‹®0 &Ü§˜œ0Œ0#o8ç#ô¯R6Û“yŽ73G¹^2½öò~o»Ÿ›##ÞSðr=ÑkÒ41º €–rØ ÷„ëƒëÎ zõo7"Ýà_=Š©‰Éldà`†qt÷+‹?æxù©%m,ö{.¶jú;%÷hÌ*ß›Uý}Äq¬fp’}¿Í¹ ü¼î Ïñg$ý*{XLI›•fBÀ\BUzr€Œr#Ð€í¥ÛÍ+²(P”x›$ÅèçœŒž tëÐÕkÖ9‘ab‡Ïò³œã#G'’¼o«U¢ùœ×Gvº4µ¾vÕí}½œ¢ïb{{)¥P’ÊÒº#«Bç˜€8Êä6GË”dTmV³$g¸i&'r:ƒ¬1œàòœãƒÒ • rñ¤P©ÑØô*IÆ[ ÝÏN¸Î9_³[™#Kr.Fí¤í*IÁ?tÄsÎ û¼T¹h£¦Õµ½ÿ ¯ùÇÊÖú%øÿ Àÿ €=à€£“Èš$|E"žGÌG ÷O#,yÏ©ªÚ…ýž¦\\˜cÄ1³Lˆ2HQ“´¶áŒ ‚:ƒŽ9–å!Š–Í‚É¾F''‘÷yÇNüûãëpÆ|=~¢D•äµ•vn2„sÓžGLë IUP´Uíw®Ú-/mm£²×Ì–ìíeý]? øÑüa¨ÞZÏeki,q‰c10PTpAÜÀg%zSß°2Ä¤¡U]®ØŠÜçžI;€èpx?_øZÊ|^agDóí¹ )ÊžßJö‰¡E]È##ço™NO÷¸ÈÇÌ0¹9>™¯Sˆ°pÃc°ŠI¤÷õ¿å}Ë¯ JñGžÿ ÂÀ+ãdÒc³Qj'ÅØîs&vç6îíŽë»iÞbü” ‚Â%\r9àg·ùÍxuÁüMg~ŸÚÁÎÜ²çŽ0?*÷WšÝ^O*#†€1èwsÎsùRÏpTp±¢è¾U(«u}íùŠ´R³²ef À9³bíÝ¿Ùéì ùïíÌóÅ1ý–F‘œ‘åà’9Àç9ëÒ‹)ˆ”©±eÎ c×sù×Î{'ÎâÚõéßuOÁœÜºØ‰fe“e6ñžyäöÀoÆ§²‹„•%fˆ80(öåO½Oj…„E€T…%rKz°Î?.;{šXÙ‡ŸeUÚd!üx9þtã%wO_øoòcM- j–ÒHX_iK#*) ž@Ž{ôÇ½Bd¹‰RÝn–ê0«7Ë†ìyÀ÷Í@¬Ì¢³³’ 9é÷½?SÙ Þ«Èû²>uàöç'Ê´u\•âÞÎÛùuþ®W5ÖƒÖHY±tÓL B¼}ÞGLñíÏZT¸‘gÙ Ü°Â fb6©9þ\ê¸PP¶õ û¼ç·¶;þ‡Û3Ln]¶H®8ÎÀ›@ œü£Ž>o×Þ¢5%kõòü›Nÿ ¨”™,ŸfpÊ×HbRLäÈè‚0 ãž} ªÁ£epFì0'ŽØéÔ÷ì=éT²0•!…Îzt9ç¾?”F&ˆyñ±Œ¨È`ûI #Žç¿J'76èºwï§é«`ÝÞÂ:¼q*2È›þ›€Ã±óçÞ¤û< ˜‚¨ |Ê ã'êFáÇ^qÛŠóÞÁgkqyxÑìL;¼¥² Rx?‡¯Y7PŽwnù¶†û¾ÜÂ·.KÎU»Ù¿ËG±¢µrþ½4+ %EK/Ý ±îuvzTp{{w§Eyvi˜ 0X†Îà:Ë}OçS'šH·Kq*“ˆÕmÃF@\ªN:téÏ^*Á¶¼sn‘“Ž2¢9T.½„\ýò@>˜7NFïNRÓ·wèôßEÕua'¬[þ¾cö¡ÌOæ¦âÅŠ². Ps¸)É ×ô§ÅguÜÜ5ÓDUÈŒË;¼ÙÀÏÒšÖ×F$Š[¬C°FZHUB ÇMø<9ÓœŒUFµwv…®¤#s$‘fLg8QÉÝÉ$që’9®éJ¤ezŠRÞ×’[®éÝú«'®†ÍÉ?zï¶¥³u3(’MSsŽ0Û@9$Ð…-‘ß¦O"§gŠ+¢n'k/ ‡“$±-µ°1–éÜôä)®ae ·2ÆŠ¾gÛ°Z¹#€r ¶9Ç|Õ¨âºŽÖIÑÖÜÇ»1Bc.çqÁR àûu®Š^Õ½Smkß}uzëmSòiõÒ<Ï×õ—£Îî6{ˆmŽåVUòãv3ü¤œqÐŒç“œô¶Ô¶¢‹{• b„ˆg©ù@ÇRTóÅqinÓ·ò×l‡1`¯+òŸ¶ÐqžÀ:fÿ Âi£häÙjz…¬wˆÄË™RI'9n½øãœv®¸ÓmªUÛ•ôI-_kK{ièßvim£Qµý|ÎoÇßìü-~Ú}´j:ÃÍŠ|¸˜¨ó× qŒŒžy®w@øßq%å½¶³imoj0¿h·F;8À,›¹¸üyu¿üO'|;´ðÄÚ¦Œ%:t„Fáß~÷O¿júß©a)ZV”ºÝïëëýjkÞHöfÔ&–î#ö«aðå'Œ’¥\™Il`õ¸9©dûLì ‹t‘ƒ¸ó"Ä€‘Ê7ÈÛŽ:vÜ ¯/ø1â`!»Ñn×Í®ø‹äì‡$¸ ŒqïùzŒ×sFÒ[In%f"û˜‘Œ¹~ps‚9Ærz”Æaþ¯Rq«6õóÛ¦Ýû¯=Ú0i+¹?ÌH¢VŒý®òheIÖr›7îf 8<ó×+žÕç[ÂÖ€]ÇpßoV%v© €pzþgµ6÷3í‹Ì’{²„äˆƒŒ‚Ìr8Æ1“Áë^{ñqæo Ø‹–¸2ý|ÇÜ¬¬Žr=;zþ¬ò¼CúÝ*|+[zÛ£³µ×ß÷‘š¨Ûúü®Sø&ì¬…˜Có[¶âÈ¼3ûÜ÷<ŒñØæ½WÈŸÌX#“3 "²ºÆ7Œ‘Üc¼‡àìFy5xKJŒ"îç.r@ï×Þ½Ä-ÿ þ“}ª}’*Þ!,Fm¸Î@†9b?1W{Yæ3„`Ú¼VõŠÚÛ_kùöG.mhÎñ ôíhí§Ô$.ƒz*(iFá’I^™$ðMUÓ|áíjéb[ËÆºo•ñDdŽà¸'“ŽA Ö¼ƒGÑµ/krG É–i\ôÉêNHÀÈV—Š>êÞ´ŠúR³ÙÈùÑõLôÜ9Æ{jô?°°Kýš¥WíZ¿V—m6·E}{X~Æ? zžÓæ8Ë¢“«¼ 39ì~¼ûÒÍ}žu-ëÇ•cÉåmÀÀÉ9Àsþ ”økâŸí]:[[ÍÍyhª¬w•BN vÏ$ôé‘Íy‹ü@þ"×ç¹ ¨v[Æ¼* ã zœdžµâàxv½LT¨T•¹7jÿ +t×ð·CP—5›=Î ¨/"i¬g¶‘#7kiÃç±'x9#Ž}êano!òKD‘ílï”('¿SÔð?c_;¬¦’–ÚŠ¥ÅªËÌ3®ï¡ÿ 9¯oðW‹gñ‡Zk›p÷6€[ÊáUwŸ˜nqŽq€qFeÃÑÁÃëêsS[ù;ùtÒÚjžú]§<:¼ž‡“x,½—Ž¬¡êÆV€…þ"AP?ãÛ&£vÂÅ»I’FÙ8ÛžÀ”œ¾ÜRÜÌ¬ŠÛÓ‘–Ä*›qôúŸÃAÀëßí-L¶š-™ƒµ¦i”øÿ g«|è*pxF:nžîË¯Þ¼¿þBŒÛQþ¿C»Š5“*]Qÿ „±À>Ý:ôä*D(cXÚ(†FL¡‰`çØÏ;þ5âR|Gñ#3î`„0+µmÑ€ún Þ£ÿ …‰â¬¦0 –¶ˆœ€¹…{tø?Ê¯(_çþ_Š5XY[¡Ù|Q¿ú µŠ2ï¸›sO* Ð‘ÿ ×â°<+à›MkÂ÷š…Ä³ ·Ü–ˆ«ò‚?ˆœúäc½øåunû]¹Iïåè› ç ¯[ð&©¥Ýxn;6>}²’'`IË0ÁèN}zö5éâ©âr\¢0¥ñs^Ml¿«%®ýM$¥F•–ç‘Øj÷Ze¦£k 2¥ô"FqÀ`„~5Ùü+Ò¤—QºÕ†GÙ—Ë‹ çqä°=¶ÏûÔÍcá¶¡/ˆ¤[ý†iK ™°"ó•Æp;`t¯MÑt}+@²¶Óí·Ídy’3mÕË‘’zc€0 íyÎq„ž ¬4×5[_]Rë{]ì¬UZ±p÷^åØÞÈ[©&OúÝÛ‚‚s÷zžIïßó btÎÎª\ya¾U;C¤t*IÎFF3Š¸™c 1žYD…U° êÄàõë\oŒ¼a ‡c[[GŽãP‘7 â znÈ>Ãü3ñ˜,=lUENŒäô¾ÚÀÓ[_ð9 œ´JçMy©E¢Àí}x,bpAó¦üdcûŒW9?Å[Há$¿¹pÄ™#^9O88©zO=«Ë!µÖüY¨³ªÍy9ûÒ1Â úôÚ»M?àô÷«ÞëÖ–ÙMÌ#C&ßnJ“Üp#Ð‚~²†G–àíekÏµío»_žŸuÎ¨Q„t“ÔÛ²øáû›´W6»Øoy FQÎr $Óõìk¬„‹ïÞÚ¼sÆíòÉ67\míÎyF¯ð¯TÓã’K;ë[ð·ld«7üyíšÉð¯Šµ êáeYžÏq[«&vMÀðßFà}p3ÅgW‡°8ØßVín›þšõ³¹/ ü,÷ií|’‘´R,®ŠÉ‡W“Ž1ØöëÓ¾xžÖÞ¹xÞÝ¬XZGù\’vŒž˜ÆsØúÓïí&ÒÒ{]Qž9£Ê¡ù·ÄÀ»¶áHäž™5—ìö« -&ù¤U<±ÉÆA>½ý+æg jžöë¥¢þNÛ=÷JÖÛfdÔ õýËúû‹ÓØB²¬fInZ8wÌÉÐ®~aƒÎ=3ìx‚+/¶äÁlŠ‚?™Æü#8-œ\pqTZXtè%»»&ÚÝ#´ŠðÜžã§Í’¼{p·ß{m>ÞycP¨’¼¢0ú(Rƒë^Ž ñó¼(»y%m´ÕÙ}ÊûékB1¨þÑ®,#Q)ó‡o1T©ÜÃ*Ž‹‚yö<b‰4×H€“ìÐ. ¤²9ÌŠ>„Žãøgšñ ¯Š~)¸ßå\ÛÛoBŒa·L²œg$‚Iã¯ZÈ—Æ~%”äë—È8â)Œcƒ‘Âàu9¯b%)ÞS²¿Ïïÿ 4Öºù}Z/[H%¤vÉ#Ì’x§†b © ³´tÜ{gn=iï%õªÇç]Ü§—!åw„SÓp ·VÈÏ¡?5Âcâb¥_Ä¤Šz¬—nàþÖÎŸñKÄöJé=ÌWèêT‹¸÷qÎáƒŸ•q’zWUN«N/ØO^Ÿe|í¾©k{üõ4öV^ïù~G¹êzÂèº|·÷×[’Þ31†rpjg·n Æ0Ý}kåË‹‰nîe¹ËÍ+™ÏVbrOç]'‰¼o®xÎh`¹Ç*±ÙÚ!T$d/$žN>¼Wqá¯…Z9ÑÒO\ÜÛê1o&,-z ~^NCgNÕéá)ÒÊ©7‰¨¯'Õþ¯þ_¿Ehîþóâ €ï¬uÛûý*ÎK9ä.â-öv<²‘×h$àãúW%ö¯~«g-ÕõÀàG~>Zú¾Iš+(šM³ Û#9äl%ðc¬ ûÝ xÖKG´x®|¸¤Ï™O:Ê8Ã’qÉcÔä‚yÇNJyËŒTj¥&µOmztjÿ ?KëaµÔù¯áýóXøãLeb¾tžAÇû`¨êGBAõ¾•:g˜’ù·,þhÀ`¬qÜ` e·~+å[±ý“âYÄjWì—µHé±ø?Nõô>½âX<5 Ç©ÏÑ¼M¶8cÜªXŽÉ^r?¼IróÈS•ZmÇ›™5»òÚÚ7ïu«&|·÷•Î† >[©ÞXHeS$Œyà€ ÷ù²:ò2|óãDf? Z¼PD¶ÓßC(xÆ0|©ßR;ôMsÿ µ´ÔVi¬,Í¹›Ìxâi˜`¹,GAéÇlV§ÄýF×Yø§ê–‘:Ã=ò2³9n±ÉžØÏ@yÎWžæ±Ãàe„ÄÒN ]ïòêìú_Go'¦ŽÑ’_×õÐ¯ðR66þ!›ÑÄ gFMÙ— äžäqôÈ;ÿ eX<#%»Aö‰ãR¤ Í”Ž¹È G&¹Ÿƒ&á?¶Zˆ±keRè Kãnz·ãŠÕøÄÒÂ9j%@®×q±ÜŒý[õ-É$uíè&¤¶9zÇï·Oøï®ÄJKšÖìdü"µˆ[j×²Îc;ã…B(g<9nàÈ¯G½µŸPÓ.´Éfâ¼FŽP 31 ‘ÏR}<3šä~ Ã2xVöî Dr Ç\›}Ý#S÷ÈÀëŽHÆI®à\OçKuäI¹†ó(”—GWî ñ³¹¸æ2¨›‹ºÚû%¾ýÖ_3ºNú¯ëúì|ÕÅÖ‰}ylM’ZËîTÿ á[ðÐñ/ˆ9Àû ¸ón3 MÃ²d‘÷ döª^.ÊñŽ°›BâîNp>cëÏçÍzïÃôÏ YÍ%ª¬·ãÏ-*9ÜÂãhéŒc¾dÈêú¼Ë,. VŠ÷çeÿ n/¡¼äãõâ=‹xGQKx”|¹bÌŠD@2Œ 8'Ž àúƒŽ+áDÒ&¡¨"Œ§–Žr22 Ç·s]ŸÄ‹«ð%ÚÄ<¹ä’(×{e›HÀqÁç©Ç½`üŽÚõKé¥š9ƒÄ±€<–úƒú~ çðñO#Í%iKKlµ¦¾F)'Iê¬Î+Ç(`ñ¾£œdÈ’`™ºcßéé^ÿ i¸”Û\ý¡æhÔB«aq¸}ãÀÆ:ÜWƒ|FÛÿ î©±BŒÇÀeaŸ-sÊ€:úW½ÜÝÜ<%$µ†%CóDªÀí%IÈÏÊ¤…ôäñÞŒ÷‘a0“ôŽÚë¤nŸoW÷0«e¶y'Å»aÎ—2r’# Û°A^ý9ÉQÔõ=ù5¬£Öü.(Þ’M$~V«=éSÄFN½®©ÔWô»ÿ þHžkR‹ìÏ+µµžöê;khÚI¤m¨‹Ôš–âÖçJ¾_Z•’6a”Èô> ÕÉaÕ<%®£2n bQŠå\tÈõUÿ ø»þ‹k15‚ÃuCL$Ý¹p P1=Oøýs¯^u éEJ”–éêŸê½5ýzy›jÛ³á›Ûkÿ ÚOcn±ÛÏîW;boºz{ãžüVÆ¡a£a5½äÎÂks¸J@?1è¿{$ä‘=k”øsÖ^nŒ¦)ÝåXÃíùN1ØõÚOJë–xF÷h¸ Œ"Ž?xäœšü³ì¨c*Fœ¯i;7~ñí×«Ðó¥Ë»3Ãü púw ‰°<Á%»ñž ÿ P+Û^ ¾Ye£ŽCÄŒ„/>˜>•á¶Ìm~&&À>M[hÈÈÿ [Ž•íd…RO@3^Ç(Ê½*¶ÖQZyßþ 1Vº}Ñç?¼O4Rh6R€ª£í¡ûÙ a‚3ß·Õ ü=mRÍ/µ9¤‚0ÑC¼Iè:cŽsÛ¾™x£ÆÐ¬ªÍöË¢ìƒ’W$•€Å{¨ÀPG ÀÀàŸZìÍ1RÉ0´ðxEË9+Éÿ ^rEÕ—±Š„70l¼áË@û.' ¼¹Žz€N3úUÉ<3á×*?²¬‚ä†"Ùc=p íÛ'¡ª1ñ"økJ†HÒ'»Ÿ+ oÏN¬Ã9 dÙãÜ×“ÏâÍ~æc+j·Jzâ7(£ðW]•æ™?nê´º6åwéåç÷N•ZŠíž›¬|?Ðõ?Ñ-E…Â®³ÇV$~X¯/…õ x‘LˆÑÜÚÈ7¦pzãÜüë½ðÄ^õtÝYËÍ7ÉÖÕ8ÏUe# #€r=sU¾/é’E§jRC4mxNÝ´9†íuá»›V‘ ZI€×cr1Ÿpzsøf»¨åV‹ìû`qËLÊIã?\~¼³áËC©êhªOîO»‘ÃmçÛçút×¢x“Z}?Ãœê#b-¤X7õÄò gž zzbº3œm*qvs·M=íúéw}¿&Úª°^Ö×µÏ(ø‡â†Öµƒenñý†×åQáYûœ÷ÇLœôÎNk¡ðÂ‡¼/µ¸n0æÉ0¬ƒ‚üîÉÆvŒw®Sáö”š¯‹-üÕVŠØÙ[$`(9cqƒÔ_@BëqûÙ`Ýæ0;79È?w<ó |ÙÜkßÌ1±Ëã¿ìÒ»ðlìï«ÓnªèèrP´NÏÂš&ŽéöÙ¸÷æ°~-_O'‰`°!RÚÚÝ%]Ø%þbß1'¿ÿ XÕáOöÎŒ·‹¬+Åæ*ÛÛ™0¤ƒOÍÔ`u¯¦ÂaèÐÃÓ«‹¨Ô¥µœ¿¯ÉyÅÙ.oÔôŸ Úx&(STðÝ½¦õ] ’ÒNóÁäÈùr3í·žÚ[™ƒ¼veÈÃ·ÞIõÎGlqÎ=M|«gsªxÅI6 ]Z·Îªä,¨zŒŽÄ~#ØŠúFñî™ªiÉqc©éÐD>Së”‘ GñŽ1éÐ^+ Ëi;Ô„µVÕú»i¯ÈÒ-ZÍ]òÜ˜®ì`bÛÙ¥_/y(@÷qÐúg Ô÷W0.Ø› 6Ò© r>QƒŒ0+Èîzb¨É+I0TbNñ"$~)ÕÒ6Þ‹{0VÆ27œWWñcÄcX×íôûyKZéðªc'iQ¿¯LaWŠŸS\·Š“ÅºÊ¸…ôÙÂí|öÀÇåV|!¤ÂGâÛ[[’ï 3OrÙËPY¹=Î1õ5öåTžÑè Ú64/üö?Zëžk}¬¶éàoá¾á}3“ü]8Éæ¿´n²Žš_6¾pœ)2?úWÓÚ¥¾¨iWúdŽq{*ª1rXŒd…m»‰äcô¯–dâ•ã‘Jº¬§¨#¨®§,df«8ÉÅßN¾hˆ;îÓ=7áùpën®É 6ûJžO2^œÐò JÖø¥²ãÂ›Ò6Ü·‰!wbÍ‚¬O©»õ¬ÿ ƒP=Ä:â¤-&ÙŽ `È9 r9íÏ§zë> XÅ7ƒ5X–krÑ¢L7€ìw}ÑŸNHëŒüþ:2†á¼+u·á÷N/Û'Ðç~ß˜ô«ëh!ónRéeQ´6QÛÿ èEwëÅÒ|¸Yqó1uêyùzð8 ƒŠù¦Ò;¹ä6öi<'ü³„[ÃZhu½ ùÍ¡g‚>r¯×ŠîÌx}bñ2“kê£§oø~›hTèóËWò4|ki"xßQ˜Ï6øÀLnß‚0 ¹Æ{±–¶Öe#¨27È@^Ìß.1N¾œyç€õ†ñeé·Õã†çQ°€=Ì©ºB€Ø8<‚ÃSõ®ùcc>×Ú .Fr:žÝGæ=kÁâ,^!Fž ¬,àµ}%¶«îõ¹†"r²ƒGœüYÕd?aÑÃY®49PyU ÷þ!žxÅm|/‚ãNð˜¼PcûTÒ,¹/Ý=FkÏ|u¨¶«âë…{¤m¢]Û¾ïP>®XãÞ½iÓÁ¾ ‰'¬–6ß¼(„ï— í!úÙäzôë^–:œ¨å|,_¿&š×]uÓÑµÛô4’j”bž§x‘Æ©ã›á,‚[Ã” ÎÞ= î®ˆŒËæ ÀùYÁ?ŽïÚ¼?ÁªxºÕÛ,°1¸‘¿ÝäãØ¯v…@¤åq½ºã œàûââ·z8Xýˆþz~—û»™âµj=Ž â~ãáh@'h¼F#·Üp?ŸëQü-løvépx»cŸø…lxâÃûGÂ·‰¶ø”L£©%y?¦úõÆü-Õ¶¥y`Òl7>q’2üA?•F}c‡jB:¸Jÿ +§¹¿¸Q÷°ív=VÑìu[Qml%R7a×IèTõéŽx¬ ?†š7 1†îã-ˆã’L¡lŽ0OÓ=ÅuˆpÇ•¼3ÛùÒ¶W/!|’wŽw^qÔ×ÏaóM8Q¨ãÑ?ëï0IEhÄa¸X•`a ?!ÐñùQ!Rä ÂžqŽžÝO`I0ÿ J“y|ñ!Îã@99>þ8–+éáu…!ù—ä Ê°<÷6’I®z ÅS„¾)Zþ_Öýµ×ËPåOwø÷þ*üïænÖùmØÝûþ¹=>¦½öî×Jh]¼ç&@§nTŒ6ITÀõ^Fxð7Å3!Ö·aÛ$þÿ ¹ã5îIo:ÈªmËY[’8ÇÓ¾Ç‰*òû¢¥xõ¾¼ú•åk+\ð¯ HÚoŽl•Ûk,¯ ç²²cõÅ{²Z\ ´ìQ åpzŽ3Ôð}ÿ Jð¯XO¡øÎé€hÙ¥ûLdŒ`““ù6Gá^ÃáÝ^Ë[Ñb¾YåŒÊ»dŽ4†2§,;ÿ CQÄ´¾°¨c–±”mºV{«ßÕýÄW\ÖŸ‘çŸ,çMRÆí“l-ƒn~ë©ÉÈê Ü?#Ž•¹ðãSÒ¥ÐWNíà½;ãž)™ÎSÈ9cóLjëµ¿Å«iÍk¨ió¶X‚7÷ƒ€yãnyÏŽëÞ Öt`×À×V's$È9Ú:ä{wÆEk€«†Çàc—â$éÎ.éí~Ýëk}ÅAÆpörÑ¢‡Šl¡ÑüSs‹¨‰IÃ„óÀ×wñ&eºðf™pŒÆ9gŽTø£lñëÀçŽ NkÊUK0U’p ï^¡ãÈ¥´ø{£ÙHp`’ØåbqÏ©äó^Æ: Ž' ÊóM«õz+ß×ó5Ÿ»('¹ð¦C„$˜Å¢_ºÈI?»^äã'ñêzž+ë€ñ-½»´}¡Ë*õ?.xÇ^1ŽMyÇÂ¸&“Â—L–îëöâ7…' bqéÎGé]Ëªâ1$o²¸R8Ã`.q€}sÖ¾C98cêÆÞíïóòvÓòùœÕfÔÚéýuèÖ·Ú Å‚_¤³ÜÛºÆ‘ÃŸ”à×¨ý:×ƒxPþÅÕî-/üØmnQìïGÎŠÙRqê=>¢½õnæ·r!—h`+’;ò3È<“Û©éšóŸx*÷V¹¸×tÈiˆßwiÔÿ |cŒñÏ®3Ö½Ì°‰Ë Qr©ö½®¼ÛoÑÙZÅÑ«Oàµ¯ýw8;k›ÿ x†;ˆJa;‘º9÷÷R+¡ñgŽí|Iáë{ôáo2Ê²9 029ÉÏLí\‰¿¸Ÿb˜ "Bv$£&#ßiê>=ªª©f ’N ëí>¡NXW~5×úíø\‰»½Ï^ø(—wÖú¥¤2íŽÞXæÁ$°eÈ888^nÝë²ñÝÔ^ ÖÚ9Q~Ëå7ï DC¶ÑµƒsËÇè9®Wáþƒ6‡£´·°2\Ý:ÈÑ?(#¨'$õèGJ¥ñW\ÿ ‰E¶—¸™g˜ÌÀ¹;Pv ú±ÎNs·ëŸ’–"Ž/:té+ûË]öJöÓM»ëø˜*‘•^Uý—êd|‰åñMæÔÝ‹23å™6æHùÛ‚ëüñ^…ñ1¢oêûÑEØ.õ7*ÅHtÎp{g<·Á«+¸c¿¿pÓ¾Æby=8É_ÄsÆk¬ñB\jÞÔì••Ë[9Píb‹Bãƒ… =93§ð§LšÛáÖšÆæXÌÞdÛP.0\ãïÛ0?™úJ¸™Ë ”•œº+=<µI£¦í¯õêt¬d‹T¬P=ËFêT>ÍØØ@Ï9<÷AQÌ×»Õ¡xùk",JÎæù±Éç$œŽŸZWH®¯"·UÌQÂ ’ÙÈ]ÅXg<ã ß¨g3-Üqe€0¢¨*Œ$Üƒ ’Sû 8ãŽ¼_/e'+Ï–-èÓ¶¶Õíß[·ÙÙ½îì—¼sk%§µxä‰â-pÒeÆCrú ôÏƒžû=”šÅô(QW‚Õd\ƒæ. \àö¹¯F½°³½0M>‘gr÷q+œ¶NïºHO— ¤ Ü¥Ý”n·J|ÆP6Kµc=Isó}Ò çGš)a=—#vK›åoK§ßóÙ¤¶¿õú…ÄRÚ[ËsöÙ¼Ë•Ë ópw®qœŒ·Ø ùÇâ‹ý‡ãKèS&ÞvûDAù‘É9ŒîqÅ} $SnIV[]Ñ´Ó}ØÜ¾A Ü|½kÅþÓ|EMuR¼.I¼¶däò‚ÃkÆ}ðy¹vciUœZ…Õõ»z¾÷¿n¦*j-É/àœHã\y5 Û ß™ó0—äŸnzôã#Ô¯,†¥ÚeÔ÷ÜÅ´„“'c…<íÝ€<·SŠ¥k§Ã¢éÆÆÙna‚8–=«Êª[Ÿ™°pNî02z“ÔÙ–K8.È’Þî(vƒ2®@ äÈûãçžxäÇf¯ˆu¹yUÕîýWšÙ|›ëÒ%Q^í[æ|éo5ï‚¼ZY•^{96ˆY‚§v*x>âº_|U¹Ö´©tûMÒÂ9PÇ#«£#€ éÉñ‘ƒÍz/‰´-Ä¯¹°dd,Ð‘›p03ƒœ{ç9=+ Ûá§‡¬¦[‡‚êå©º¸#±ß=³ý¿•Õµjñ½HÙh›Û[§ÚýÊöô÷{˜?ô÷·Ô.u©–_%còcAÀ˜’ }0x9Î>žñÇáÍ9,ahï¦Ì2òÓ ñÛAäry$V²Nð ]=$Ž ‚#Ù‚1ƒƒødõMax‡ÂÖ^!±KkÛ‘ «“Çó²FN8+ëÎ{Ò¼oí§[«ÕMRoËeç×[_m/¦¦k.kôgŽxsSÓ´ý`êzªÜÜKo‰cPC9ÎY‰#§^üý9¹âïÞx£Ë·Ú`±‰‹¤;³–=ÏaôÕAð‚÷kêÁNBéÎælcõö®£Fð†ô2Ò¬]ßÂK$ÓÜ®•”/ÊHàã$ä¸÷ëf¹Oµúâ“”’²øè´µþöjçNü÷üÌ¿ xNïFÒd»¼·h®îT9ŽAµÖ>qÁçÔœtïÒ»\È¶ÎîcÞäîó3¶@#ÉIÎ ÔñW.<´’¥–ÑÑ€ÕšA‚ ;†qÓë‚2q ÒÂó$# Çí‡ !Ë}Õ9ÈÎÑÉã=;ŒÇÎuñ+ÉûÏ¥öíeÙ+$úíÜå¨¯'+êZH4ƒq¶FV‹gïŒ208ÆÌ)íÐ±>M|÷âÍãÂ¾"iì‹¥£Jd´™OÝç;sÈúr+ÜäˆË)DŒ¥šF°*3Õ”d{zÔwºQ¿·UžÉf†~>I+ŒqÔ`ð3œ“Ü×f]œTÁÔn4“ƒø’Ýßõ_«*5šzGCÊ,þ+ê1Ã²÷O¶¸cœºb2yÇ;cùÕ£ñh¬›áÑŠr¤ÝäNBk¥—á—†gxšX/ì‘˜hŸ*Tçn =ûã¦2|(ð¿e·ºÖ$ ýìŸ!'åÎ°yîî+×öœ=Y:²¦ÓÞ×iü’—ü -BK™£˜›âÆ¡&véðõ-ûÉY¹=Onj¹ø¯¯yf4·±T Pó`çœ7={×mÃ/¢˜ZÚòK…G½¥b„’G AãÜœ*í¯Ã¿ IoæI¦NU8‘RwÈã;·€ Û×ëÒ”1Y •£E»ÿ Oyto¢<£Áö·šï,ä‰§ûA¼sû»Nò}¹üE{ÜÖªò1’õÞr0â}ÎØ#>à/8ïéÎ~—áÍ#Ã±Îlí§³2f'h”?C÷YËdð:qëõÓ·‚ïeÄ© ÔÈØÜRL+žAÎ3¼g=åšó³Œt3 ÑQ¦ùRÙßE®¼±w_;þhš’Sirÿ ^ˆã¼ià©‡|RòO„m°J/“$·l“ ÇÓ¿ÿ [ÑŠÆ“„†Õø>cFÆ6Ø1ƒ– àz7Ldòxäüwá‹ÝAXùO•Úý’é®ähm •NÀ±ÌTÈç ƒ‘I$pGž:‚ÄbêW¢®œ´|¦nÍ>¶ÖÏ¢§ÎÜ¢ºö¹•%ÄqL^öÛKpNA<ã¡ …î==ª¸óffËF‡yÌcÉ ©ç$ð=ñÏYþÊ’Ú]—¥‚¬‚eDïÎH>Ÿ_ÌTP™aÂ‰ch['çÆÜò7a‡?w°Ïn§âÎ5”’¨¹uÚÛ|´ÓÓc§{O—ü1•ªxsÃZ…ÊÏy¡Ã3¸Ë2Èé» ‘ƒÎ äžÜðA§cáOéúÛ4ý5-fŒï„ù¬ûô.Ç Üsž•Ò¾•wo<¶Ÿ"¬¡º|£ î2sÇ¡éE²ÉFÑ±rU°dÜ6œ¨ mc†Îxë×ºÞ'0²¡Rr„{j¾í·è›µ÷)º·å–‹î2|I®Y¼ºÍË·–ÃÆàã£'óÆxƒOÆÞ&>\lóÌxP Xc¸ì Sþ5§qà/ê>#žÞW¸if$\3 ® ûÄ“ùŽÕê¾ð<Ó‹H¶óÏ" å·( á‘€:ã†8Ï=+ê¨¬UA×ÃËÚT’ÑÞöù¥¢]{»ms¥F0\ÑÕ—ô}&ÛB´ƒOŽÚ+›xíÄÀ1 ,v± žIëíZ0Ç§™3í2®0à¸—p9öÝÔž)ÓZËoq/Ú“‘L ²ŒmùŽï‘Ó9§[Û#Ä‘\ÞB¬Çs [;à à«g‚2ôòªœÝV§»·¯/[uó½õÛï¾ /šÍ}öüÿ «=x»HŸÂÞ.™ ÌQùŸh´‘#a$‚'¡u<Š›Æ>2>+ƒLSiöwµFó1!eg`£åœ ÷ëÛö}Á¿ÛVÙêv $¬ƒ|,s÷z€ðÎƒ¨x÷ÅD\ÜŒÞmåÔ„ ˆ o| :{ÇÓ¶–òÁn!´0Ål€, ƒ ( ÛŒŒc¶rsšæ,4‹MÛOH!@¢ ÇŽ„`å²9ÝÃw;AÍt0®¤¡…¯ØÄ.Àìí´ƒ‘ßñ5Í,Óëu-ÈÔc¢KÃÓ£òÖÌºU.õL¯0…%2È—"~x ‚[`có±nHàŽyàö™¥keˆìŒÛFç{(Ø©†`Jã#Žwg<“:ÚÉ;M ^\yhûX‡vB·÷zrF?§BÊÔ/s<ÐÈB)Û± ·ÍÔwç5Âã:så§e{mÑ¤ï«Òíh—]Wm4âí¿ùþW4bC3¶ª¾Ùr$pw`àädzt!yŠI„hÂîàM)!edŒm'æ>Ç?wzºKìcŒ´¯Ìq6fp$)ãw¡éUl`µ»ARAˆÝÕgr:äŒgƒéé[Ôö±”iYs5Ýï«ÙG—K=þF’æMG«óÿ `ŠKÉ¦uOQ!ÕåŒ/ÎGÞ`@ËqÕzdõâ«Ê/Ö(ƒK´%ŽbMüåÜŸö—>¤óŒŒV‘°„I¢Yž#™¥ùÏÊ@8 œgqöö5ª4v×“[¬(q cò¨À!FGaÁõõ¯?§†¥ÏU½í¿WªZ$úyú½Žz×§Éþ?>Ã×È•6°{™™ŽÙ.$`ÎUœ…çè ' ¤r$1Ø(y7 ðV<ž:È ÁÎMw¾Â'Øb§øxb7gãÐž½óÉÊë²,i„FÈ¹£§8ãäÂ½k¹¥¦ê/ç{ïêï¦‡2œ/«ü?¯Ô›ìñÜ$þeýœRIåŒg9Ác’zrrNO bÚi¢ ÑºË/$,“ª¯Ýä;Œ× ´<ÛÑn³IvŸb™¥ nm–ÄŸ—nÝÀãŽ3ëÍG,.öó³˜Ù£¹uÊÌrŠ[<±!@Æ:c9ÅZh ì’M5ÄìÌ-‚¼ëÉùqŽGì9¬á ;¨A-ž—évþÖ–^ON·Ô”ŸEý}ú×PO&e[]ÒG¸˜Ûp ƒÃà/Ë·8ûÀ€1ž@¿ÚB*²¼ñì8@p™8Q“žÆH'8«I-%¸‚ F»“åó6°Uù|¶Ú¸ã ò^Äw¥ŠÖK–1ÜÝK,Žddlí²0PÀü“×ükG…¯U«·¶–´w¶ŽÍ¾©yÞú[Zös•¯Á[™6° ¨¼ÉVæq·,# ìãï‘×8îry®A››¨,ãc66»Ë´ã'æÉù?t}¢æH--Òá"›|ˆ¬[í 7¶ö#¸9«––‹$,+Ëqœ\Êøc€yê^Ý¸Äa°«™B-9%«×®‹V´w~vÜTéê¢·þ¼ˆ%·¹• ’[xç•÷2gØS?6åÀÚ õ9É#š@÷bT¸º²C*3Bá¤òÎA9 =úU§Ó"2Ãlá0iÝIc‚2Î@%öç94ùô»'»HÄ¥Ô¾@à Tp£šíx:úÊ:5eºßMý×wµ›Ó_+šº3Ýyvÿ "ºÇ<ÂI>Õ1G·Ë«È«É# àÈÇ øp Jv·šæDûE¿›†Ë’NFr2qŸ½ÇAÜšu•´éí#Ä¦8£2”Ú2Ã/€[ÎTr;qŠz*ý’Îþ(â‰ ;¡TÆâ›;ºÿ àçœk‘Þ8¾Uª¾íé{^×IZéwÓkXÉûÑZo¯_øo×È¡¬ â–ÞR§2„‚Àœü½ùç® SVa†Âüª¼±D‘ŒísŸàä|ä2 æ[‹z”¯s{wn„ÆmáóCO+†GO8Ïeçåº`¯^¼ðG5f{Xžä,k‰<á y™¥voÆ éÛõëI=œ1‹éíÔÀÑ)R#;AÂncäŽ:tÏ#¶TkB.0Œ-ÖÞZÛgumß}fÎJÉ+#2êÔP£žùÈÅi¢%œ3P*Yƒò‚Aì“Ž2r:ƒÐúñiRUQq‰H9!”={~¼“JŽV¥»×²m.ÛßºiYl¾òk˜gL³·rT• ’…wHÁ6ä`–Î3ùÌ4Øe³†&òL‘•%clyÃ®AÂäà0 žüç$[3uÅ˜î¹•pNOÀÉ=† cï{rYK ååä~FÁ •a»"Lär1Ó¯2Äõæ<™C•.fÕ»è¥~½-¿g½Â4¡{[ør¨¶·Žõäx¥’l®qpwÇ»8ärF \cŽ¸ÜÆÓ-g‚yciÏÀ¾rÎwèØÈ#o°Á9ã5¢šfÔxÞæfGusÏÌJÿ µ×œ/LtãÅT7²¶w,l É³;”eúà·¨çîŒsÜgTÃS¦^ '~‹®›¯+k÷ZÖd©Æ*Ó[Ü«%Œk0ŽXƒ”$k#È¨ P2bv‘ƒŸáÇ™ÆÕb)m$É*8óLE‘8'–ÜN Úyàúô+{uº±I'wvš4fÜr íì½=úuú sFlìV$‘ö†HÑù€$§ õ=½¸«Ž] :Ž+•¦ïmRþ½l´îÊT#nkiøÿ _ðÆT¶7Ò½ºÒ£Î¸d\ã8=yãŽÜäR{x]ZâÚé#¸r²#»ÎHÆ6õ ç® ÎFkr;sºÄ.&;só±Ç9êH÷ýSšÕtÐU¢-n Ì| vqœ„{gŒt§S.P‹’Ž‰_[;m¥ÞZýRûÂX{+¥úü¼ú•-àÓ7!„G"“´‹žƒnrYXã¸îp éœ!ÓoPÌtÑ (‰Þ¹é€sÓ#GLçÕšÑnJý¡!‘Tä#“ß?îýp}xÇ‚I¥Õn#·¸–y'qó@r[ Êô÷<ÔWÃÓ¢áN¥4Ô’I&Ý¼¬¬¼ÞºvéÆ FQV~_ÒüJÖÚt¥¦Xá3BÄP^%ÈÎW-×c¡ú©¤·Iþèk¥š?–UQåIR[’O 5x\ÉhÆI¶K4«2ùªŠŒ<¼óœçØ`u«‚Í.VHä€ Ëgfx''9ÆI#±®Z8 sISºku¢ßÞ]úk»Jößl¡B.Ü»ÿ MWe °·Ž%šêÉ†¼»Âù³´œ O¿cÐÓÄh©"ÛÜÏ.ÖV’3nüÄmnq[ŒòznšÖ>J¬òˆæ…qýØP Ž:ä7^0yëWšÍ_79äoaÈ °#q0{ää×mœy”R{vÒÞ¶ÚÏe¥“ÚÆÐ¥Ì®—õýjR •íç›Ìb„+JyÜØÙ•Ç]¿Ôd þËOL²”9-Œ—õÃc'æÝ×œçÚ²ìejP“½ âù°¨†ðqòädÐƒÉäÖÜj÷PÇp“ÍšŠå«‘î <iWNsmª»¶vÓz5»ûì:Rs\Ðßôû×uÔÿÙ