From 6e7d66a40428088282c43d15e7ecf9aa66078096 Mon Sep 17 00:00:00 2001 From: DongHun Kwak Date: Wed, 25 Sep 2019 15:36:48 +0900 Subject: Imported Upstream version 20190801 --- doc/syntax.txt | 4 + kokoro/bazel.sh | 8 +- re2/compile.cc | 2 +- re2/dfa.cc | 24 +- re2/make_unicode_casefold.py | 26 +- re2/make_unicode_groups.py | 40 +- re2/nfa.cc | 11 +- re2/onepass.cc | 12 +- re2/parse.cc | 6 +- re2/prefilter.cc | 28 +- re2/prefilter_tree.h | 2 +- re2/prog.cc | 8 +- re2/re2.cc | 15 +- re2/testing/backtrack.cc | 5 +- re2/testing/charclass_test.cc | 2 +- re2/testing/compile_test.cc | 2 +- re2/testing/dfa_test.cc | 12 +- re2/testing/dump.cc | 2 +- re2/testing/exhaustive_tester.cc | 2 +- re2/testing/filtered_re2_test.cc | 32 +- re2/testing/mimics_pcre_test.cc | 6 +- re2/testing/parse_test.cc | 8 +- re2/testing/possible_match_test.cc | 4 +- re2/testing/re2_test.cc | 14 +- re2/testing/required_prefix_test.cc | 12 +- re2/testing/search_test.cc | 2 +- re2/testing/simplify_test.cc | 2 +- re2/testing/tester.cc | 8 +- re2/tostring.cc | 4 +- re2/unicode.py | 20 +- re2/unicode_casefold.cc | 23 +- re2/unicode_groups.cc | 8007 ++++++++++++++++++----------------- util/pcre.cc | 7 +- util/strutil.cc | 15 - util/strutil.h | 2 - util/util.h | 2 +- 36 files changed, 4261 insertions(+), 4118 deletions(-) diff --git a/doc/syntax.txt b/doc/syntax.txt index c87494e..cb04bbf 100644 --- a/doc/syntax.txt +++ b/doc/syntax.txt @@ -264,6 +264,7 @@ Dogra Duployan Egyptian_Hieroglyphs Elbasan +Elymaic Ethiopic Georgian Glagolitic @@ -321,10 +322,12 @@ Mro Multani Myanmar Nabataean +Nandinagari New_Tai_Lue Newa Nko Nushu +Nyiakeng_Puachue_Hmong Ogham Ol_Chiki Old_Hungarian @@ -375,6 +378,7 @@ Tifinagh Tirhuta Ugaritic Vai +Wancho Warang_Citi Yi Zanabazar_Square diff --git a/kokoro/bazel.sh b/kokoro/bazel.sh index 6f25982..95aee2e 100755 --- a/kokoro/bazel.sh +++ b/kokoro/bazel.sh @@ -4,8 +4,8 @@ set -eux cd git/re2 bazel clean -bazel build --compilation_mode=dbg -- //... -bazel test --compilation_mode=dbg --test_output=errors -- //... \ +bazel build --compilation_mode=dbg -- //:all +bazel test --compilation_mode=dbg --test_output=errors -- //:all \ -//:dfa_test \ -//:exhaustive1_test \ -//:exhaustive2_test \ @@ -14,8 +14,8 @@ bazel test --compilation_mode=dbg --test_output=errors -- //... \ -//:random_test bazel clean -bazel build --compilation_mode=opt -- //... -bazel test --compilation_mode=opt --test_output=errors -- //... \ +bazel build --compilation_mode=opt -- //:all +bazel test --compilation_mode=opt --test_output=errors -- //:all \ -//:dfa_test \ -//:exhaustive1_test \ -//:exhaustive2_test \ diff --git a/re2/compile.cc b/re2/compile.cc index ab18cef..7457b22 100644 --- a/re2/compile.cc +++ b/re2/compile.cc @@ -695,7 +695,7 @@ static struct ByteRangeProg { void Compiler::Add_80_10ffff() { int inst[arraysize(prog_80_10ffff)] = { 0 }; // does not need to be initialized; silences gcc warning - for (int i = 0; i < arraysize(prog_80_10ffff); i++) { + for (size_t i = 0; i < arraysize(prog_80_10ffff); i++) { const ByteRangeProg& p = prog_80_10ffff[i]; int next = 0; if (p.next >= 0) diff --git a/re2/dfa.cc b/re2/dfa.cc index 81adb30..40880f9 100644 --- a/re2/dfa.cc +++ b/re2/dfa.cc @@ -119,7 +119,6 @@ class DFA { // byte c, the next state should be s->next_[c]. struct State { inline bool IsMatch() const { return (flag_ & kFlagMatch) != 0; } - void SaveMatch(std::vector* v); int* inst_; // Instruction pointers in the state. int ninst_; // # of inst_ pointers. @@ -510,10 +509,10 @@ std::string DFA::DumpWorkq(Workq* q) { const char* sep = ""; for (Workq::iterator it = q->begin(); it != q->end(); ++it) { if (q->is_mark(*it)) { - StringAppendF(&s, "|"); + s += "|"; sep = ""; } else { - StringAppendF(&s, "%s%d", sep, *it); + s += StringPrintf("%s%d", sep, *it); sep = ","; } } @@ -530,20 +529,20 @@ std::string DFA::DumpState(State* state) { return "*"; std::string s; const char* sep = ""; - StringAppendF(&s, "(%p)", state); + s += StringPrintf("(%p)", state); for (int i = 0; i < state->ninst_; i++) { if (state->inst_[i] == Mark) { - StringAppendF(&s, "|"); + s += "|"; sep = ""; } else if (state->inst_[i] == MatchSep) { - StringAppendF(&s, "||"); + s += "||"; sep = ""; } else { - StringAppendF(&s, "%s%d", sep, state->inst_[i]); + s += StringPrintf("%s%d", sep, state->inst_[i]); sep = ","; } } - StringAppendF(&s, " flag=%#x", state->flag_); + s += StringPrintf(" flag=%#x", state->flag_); return s; } @@ -714,6 +713,15 @@ DFA::State* DFA::WorkqToCachedState(Workq* q, Workq* mq, uint32_t flag) { } } + // If we're in many match mode, canonicalize for similar reasons: + // we have an unordered set of states (i.e. we don't have Marks) + // and sorting will reduce the number of distinct sets stored. + if (kind_ == Prog::kManyMatch) { + int* ip = inst; + int* ep = ip + n; + std::sort(ip, ep); + } + // Append MatchSep and the match IDs in mq if necessary. if (mq != NULL) { inst[n++] = MatchSep; diff --git a/re2/make_unicode_casefold.py b/re2/make_unicode_casefold.py index d215eb1..0cf0d35 100755 --- a/re2/make_unicode_casefold.py +++ b/re2/make_unicode_casefold.py @@ -9,6 +9,10 @@ """Generate C++ table for Unicode case folding.""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + import sys import unicode @@ -57,8 +61,8 @@ def _AddDelta(a, delta): return a+1 else: return a-1 - print >>sys.stderr, "Bad Delta: ", delta - raise "Bad Delta" + print("Bad Delta:", delta, file=sys.stderr) + raise unicode.Error("Bad Delta") def _MakeRanges(pairs): """Turn a list like [(65,97), (66, 98), ..., (90,122)] @@ -122,7 +126,7 @@ def main(): foldpairs.append([c[i-1], c[i]]) lowerpairs = [] - for lower, group in lowergroups.iteritems(): + for lower, group in lowergroups.items(): for g in group: if g != lower: lowerpairs.append([g, lower]) @@ -130,18 +134,18 @@ def main(): def printpairs(name, foldpairs): foldpairs.sort() foldranges = _MakeRanges(foldpairs) - print "// %d groups, %d pairs, %d ranges" % (len(casegroups), len(foldpairs), len(foldranges)) - print "const CaseFold unicode_%s[] = {" % (name,) + print("// %d groups, %d pairs, %d ranges" % (len(casegroups), len(foldpairs), len(foldranges))) + print("const CaseFold unicode_%s[] = {" % (name,)) for lo, hi, delta in foldranges: - print "\t{ %d, %d, %s }," % (lo, hi, delta) - print "};" - print "const int num_unicode_%s = %d;" % (name, len(foldranges),) - print "" + print("\t{ %d, %d, %s }," % (lo, hi, delta)) + print("};") + print("const int num_unicode_%s = %d;" % (name, len(foldranges))) + print("") - print _header + print(_header) printpairs("casefold", foldpairs) printpairs("tolower", lowerpairs) - print _trailer + print(_trailer) if __name__ == '__main__': main() diff --git a/re2/make_unicode_groups.py b/re2/make_unicode_groups.py index e97d47e..46aef40 100755 --- a/re2/make_unicode_groups.py +++ b/re2/make_unicode_groups.py @@ -5,6 +5,10 @@ """Generate C++ tables for Unicode Script and Category groups.""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + import sys import unicode @@ -41,17 +45,17 @@ def MakeRanges(codes): def PrintRanges(type, name, ranges): """Print the ranges as an array of type named name.""" - print "static const %s %s[] = {" % (type, name,) + print("static const %s %s[] = {" % (type, name)) for lo, hi in ranges: - print "\t{ %d, %d }," % (lo, hi) - print "};" + print("\t{ %d, %d }," % (lo, hi)) + print("};") # def PrintCodes(type, name, codes): # """Print the codes as an array of type named name.""" -# print "static %s %s[] = {" % (type, name,) +# print("static %s %s[] = {" % (type, name)) # for c in codes: -# print "\t%d," % (c,) -# print "};" +# print("\t%d," % (c,)) +# print("};") def PrintGroup(name, codes): """Print the data structures for the group of codes. @@ -92,20 +96,22 @@ def PrintGroup(name, codes): return ugroup def main(): - print _header + categories = unicode.Categories() + scripts = unicode.Scripts() + print(_header) ugroups = [] - for name, codes in unicode.Categories().iteritems(): - ugroups.append(PrintGroup(name, codes)) - for name, codes in unicode.Scripts().iteritems(): - ugroups.append(PrintGroup(name, codes)) - print "// %d 16-bit ranges, %d 32-bit ranges" % (n16, n32) - print "const UGroup unicode_groups[] = {"; + for name in sorted(categories): + ugroups.append(PrintGroup(name, categories[name])) + for name in sorted(scripts): + ugroups.append(PrintGroup(name, scripts[name])) + print("// %d 16-bit ranges, %d 32-bit ranges" % (n16, n32)) + print("const UGroup unicode_groups[] = {") ugroups.sort() for ug in ugroups: - print "\t%s," % (ug,) - print "};" - print "const int num_unicode_groups = %d;" % (len(ugroups),) - print _trailer + print("\t%s," % (ug,)) + print("};") + print("const int num_unicode_groups = %d;" % (len(ugroups),)) + print(_trailer) if __name__ == '__main__': main() diff --git a/re2/nfa.cc b/re2/nfa.cc index e459b6f..7bb4faf 100644 --- a/re2/nfa.cc +++ b/re2/nfa.cc @@ -429,13 +429,14 @@ std::string NFA::FormatCapture(const char** capture) { std::string s; for (int i = 0; i < ncapture_; i+=2) { if (capture[i] == NULL) - StringAppendF(&s, "(?,?)"); + s += "(?,?)"; else if (capture[i+1] == NULL) - StringAppendF(&s, "(%d,?)", (int)(capture[i] - btext_)); + s += StringPrintf("(%d,?)", + (int)(capture[i] - btext_)); else - StringAppendF(&s, "(%d,%d)", - (int)(capture[i] - btext_), - (int)(capture[i+1] - btext_)); + s += StringPrintf("(%d,%d)", + (int)(capture[i] - btext_), + (int)(capture[i+1] - btext_)); } return s; } diff --git a/re2/onepass.cc b/re2/onepass.cc index e04c56d..d615893 100644 --- a/re2/onepass.cc +++ b/re2/onepass.cc @@ -597,15 +597,15 @@ bool Prog::IsOnePass() { if (nodeindex == -1) continue; OneState* node = IndexToNode(nodes.data(), statesize, nodeindex); - StringAppendF(&dump, "node %d id=%d: matchcond=%#x\n", - nodeindex, id, node->matchcond); + dump += StringPrintf("node %d id=%d: matchcond=%#x\n", + nodeindex, id, node->matchcond); for (int i = 0; i < bytemap_range_; i++) { if ((node->action[i] & kImpossible) == kImpossible) continue; - StringAppendF(&dump, " %d cond %#x -> %d id=%d\n", - i, node->action[i] & 0xFFFF, - node->action[i] >> kIndexShift, - idmap[node->action[i] >> kIndexShift]); + dump += StringPrintf(" %d cond %#x -> %d id=%d\n", + i, node->action[i] & 0xFFFF, + node->action[i] >> kIndexShift, + idmap[node->action[i] >> kIndexShift]); } } LOG(ERROR) << "nodes:\n" << dump; diff --git a/re2/parse.cc b/re2/parse.cc index f0a1387..93b922a 100644 --- a/re2/parse.cc +++ b/re2/parse.cc @@ -801,7 +801,7 @@ void Regexp::RemoveLeadingString(Regexp* re, int n) { // limit on the size of a concatenation, so we should never // see more than two here. Regexp* stk[4]; - int d = 0; + size_t d = 0; while (re->op() == kRegexpConcat) { if (d < arraysize(stk)) stk[d++] = re; @@ -832,8 +832,8 @@ void Regexp::RemoveLeadingString(Regexp* re, int n) { } // If re is now empty, concatenations might simplify too. - while (d-- > 0) { - re = stk[d]; + while (d > 0) { + re = stk[--d]; Regexp** sub = re->sub(); if (sub[0]->op() == kRegexpEmptyMatch) { sub[0]->Decref(); diff --git a/re2/prefilter.cc b/re2/prefilter.cc index 4d6df8d..f61d54b 100644 --- a/re2/prefilter.cc +++ b/re2/prefilter.cc @@ -140,35 +140,35 @@ Prefilter* Prefilter::Or(Prefilter* a, Prefilter* b) { return AndOr(OR, a, b); } -static void SimplifyStringSet(std::set *ss) { +static void SimplifyStringSet(std::set* ss) { // Now make sure that the strings aren't redundant. For example, if // we know "ab" is a required string, then it doesn't help at all to // know that "abc" is also a required string, so delete "abc". This // is because, when we are performing a string search to filter - // regexps, matching ab will already allow this regexp to be a - // candidate for match, so further matching abc is redundant. - + // regexps, matching "ab" will already allow this regexp to be a + // candidate for match, so further matching "abc" is redundant. + // Note that we must ignore "" because find() would find it at the + // start of everything and thus we would end up erasing everything. for (SSIter i = ss->begin(); i != ss->end(); ++i) { + if (i->empty()) + continue; SSIter j = i; ++j; while (j != ss->end()) { - // Increment j early so that we can erase the element it points to. - SSIter old_j = j; + if (j->find(*i) != std::string::npos) { + j = ss->erase(j); + continue; + } ++j; - if (old_j->find(*i) != std::string::npos) - ss->erase(old_j); } } } Prefilter* Prefilter::OrStrings(std::set* ss) { + Prefilter* or_prefilter = new Prefilter(NONE); SimplifyStringSet(ss); - Prefilter* or_prefilter = NULL; - if (!ss->empty()) { - or_prefilter = new Prefilter(NONE); - for (SSIter i = ss->begin(); i != ss->end(); ++i) - or_prefilter = Or(or_prefilter, FromString(*i)); - } + for (SSIter i = ss->begin(); i != ss->end(); ++i) + or_prefilter = Or(or_prefilter, FromString(*i)); return or_prefilter; } diff --git a/re2/prefilter_tree.h b/re2/prefilter_tree.h index 10d6f7c..b2e2d74 100644 --- a/re2/prefilter_tree.h +++ b/re2/prefilter_tree.h @@ -7,7 +7,7 @@ // The PrefilterTree class is used to form an AND-OR tree of strings // that would trigger each regexp. The 'prefilter' of each regexp is -// added tp PrefilterTree, and then PrefilterTree is used to find all +// added to PrefilterTree, and then PrefilterTree is used to find all // the unique strings across the prefilters. During search, by using // matches from a string matching engine, PrefilterTree deduces the // set of regexps that are to be triggered. The 'string matching diff --git a/re2/prog.cc b/re2/prog.cc index 9853d6d..5155943 100644 --- a/re2/prog.cc +++ b/re2/prog.cc @@ -134,7 +134,7 @@ static std::string ProgToString(Prog* prog, Workq* q) { for (Workq::iterator i = q->begin(); i != q->end(); ++i) { int id = *i; Prog::Inst* ip = prog->inst(id); - StringAppendF(&s, "%d. %s\n", id, ip->Dump().c_str()); + s += StringPrintf("%d. %s\n", id, ip->Dump().c_str()); AddToQueue(q, ip->out()); if (ip->opcode() == kInstAlt || ip->opcode() == kInstAltMatch) AddToQueue(q, ip->out1()); @@ -147,9 +147,9 @@ static std::string FlattenedProgToString(Prog* prog, int start) { for (int id = start; id < prog->size(); id++) { Prog::Inst* ip = prog->inst(id); if (ip->last()) - StringAppendF(&s, "%d. %s\n", id, ip->Dump().c_str()); + s += StringPrintf("%d. %s\n", id, ip->Dump().c_str()); else - StringAppendF(&s, "%d+ %s\n", id, ip->Dump().c_str()); + s += StringPrintf("%d+ %s\n", id, ip->Dump().c_str()); } return s; } @@ -180,7 +180,7 @@ std::string Prog::DumpByteMap() { while (c < 256-1 && bytemap_[c+1] == b) c++; int hi = c; - StringAppendF(&map, "[%02x-%02x] -> %d\n", lo, hi, b); + map += StringPrintf("[%02x-%02x] -> %d\n", lo, hi, b); } return map; } diff --git a/re2/re2.cc b/re2/re2.cc index fe8eb34..a4b4992 100644 --- a/re2/re2.cc +++ b/re2/re2.cc @@ -368,7 +368,7 @@ bool RE2::Replace(std::string* str, const StringPiece& rewrite) { StringPiece vec[kVecSize]; int nvec = 1 + MaxSubmatch(rewrite); - if (nvec > arraysize(vec)) + if (nvec > static_cast(arraysize(vec))) return false; if (!re.Match(*str, 0, str->size(), UNANCHORED, vec, nvec)) return false; @@ -388,7 +388,7 @@ int RE2::GlobalReplace(std::string* str, const StringPiece& rewrite) { StringPiece vec[kVecSize]; int nvec = 1 + MaxSubmatch(rewrite); - if (nvec > arraysize(vec)) + if (nvec > static_cast(arraysize(vec))) return false; const char* p = str->data(); @@ -460,7 +460,7 @@ bool RE2::Extract(const StringPiece& text, std::string* out) { StringPiece vec[kVecSize]; int nvec = 1 + MaxSubmatch(rewrite); - if (nvec > arraysize(vec)) + if (nvec > static_cast(arraysize(vec))) return false; if (!re.Match(text, 0, text.size(), UNANCHORED, vec, nvec)) @@ -816,7 +816,7 @@ bool RE2::DoMatch(const StringPiece& text, StringPiece stkvec[kVecSize]; StringPiece* heapvec = NULL; - if (nvec <= arraysize(stkvec)) { + if (nvec <= static_cast(arraysize(stkvec))) { vec = stkvec; } else { vec = new StringPiece[nvec]; @@ -882,9 +882,10 @@ bool RE2::CheckRewriteString(const StringPiece& rewrite, } if (max_token > NumberOfCapturingGroups()) { - SStringPrintf(error, "Rewrite schema requests %d matches, " - "but the regexp only has %d parenthesized subexpressions.", - max_token, NumberOfCapturingGroups()); + *error = StringPrintf( + "Rewrite schema requests %d matches, but the regexp only has %d " + "parenthesized subexpressions.", + max_token, NumberOfCapturingGroups()); return false; } return true; diff --git a/re2/testing/backtrack.cc b/re2/testing/backtrack.cc index d535dd4..ae9fd82 100644 --- a/re2/testing/backtrack.cc +++ b/re2/testing/backtrack.cc @@ -116,7 +116,7 @@ bool Backtracker::Search(const StringPiece& text, const StringPiece& context, endmatch_ = prog_->anchor_end(); submatch_ = submatch; nsubmatch_ = nsubmatch; - CHECK(2*nsubmatch_ < arraysize(cap_)); + CHECK_LT(2*nsubmatch_, static_cast(arraysize(cap_))); memset(cap_, 0, sizeof cap_); // We use submatch_[0] for our own bookkeeping, @@ -201,7 +201,8 @@ bool Backtracker::Try(int id, const char* p) { return false; case kInstCapture: - if (0 <= ip->cap() && ip->cap() < arraysize(cap_)) { + if (0 <= ip->cap() && + ip->cap() < static_cast(arraysize(cap_))) { // Capture p to register, but save old value. const char* q = cap_[ip->cap()]; cap_[ip->cap()] = p; diff --git a/re2/testing/charclass_test.cc b/re2/testing/charclass_test.cc index 7e0169c..a2837a6 100644 --- a/re2/testing/charclass_test.cc +++ b/re2/testing/charclass_test.cc @@ -197,7 +197,7 @@ bool CorrectCC(CharClass *cc, CCTest *t, const char *desc) { TEST(TestCharClassBuilder, Adds) { int nfail = 0; - for (int i = 0; i < arraysize(tests); i++) { + for (size_t i = 0; i < arraysize(tests); i++) { CharClassBuilder ccb; CCTest* t = &tests[i]; for (int j = 0; t->add[j].lo >= 0; j++) diff --git a/re2/testing/compile_test.cc b/re2/testing/compile_test.cc index 2accba1..6b77cf9 100644 --- a/re2/testing/compile_test.cc +++ b/re2/testing/compile_test.cc @@ -113,7 +113,7 @@ static Test tests[] = { TEST(TestRegexpCompileToProg, Simple) { int failed = 0; - for (int i = 0; i < arraysize(tests); i++) { + for (size_t i = 0; i < arraysize(tests); i++) { const re2::Test& t = tests[i]; Regexp* re = Regexp::Parse(t.regexp, Regexp::PerlX|Regexp::Latin1, NULL); if (re == NULL) { diff --git a/re2/testing/dfa_test.cc b/re2/testing/dfa_test.cc index 09d31f8..fb3cc14 100644 --- a/re2/testing/dfa_test.cc +++ b/re2/testing/dfa_test.cc @@ -295,7 +295,7 @@ ReverseTest reverse_tests[] = { TEST(DFA, ReverseMatch) { int nfail = 0; - for (int i = 0; i < arraysize(reverse_tests); i++) { + for (size_t i = 0; i < arraysize(reverse_tests); i++) { const ReverseTest& t = reverse_tests[i]; Regexp* re = Regexp::Parse(t.regexp, Regexp::LikePerl, NULL); ASSERT_TRUE(re != NULL); @@ -350,7 +350,7 @@ CallbackTest callback_tests[] = { TEST(DFA, Callback) { int nfail = 0; - for (int i = 0; i < arraysize(callback_tests); i++) { + for (size_t i = 0; i < arraysize(callback_tests); i++) { const CallbackTest& t = callback_tests[i]; Regexp* re = Regexp::Parse(t.regexp, Regexp::LikePerl, NULL); ASSERT_TRUE(re != NULL); @@ -360,12 +360,12 @@ TEST(DFA, Callback) { prog->BuildEntireDFA(Prog::kLongestMatch, [&](const int* next, bool match) { ASSERT_TRUE(next != NULL); if (!dump.empty()) - StringAppendF(&dump, " "); - StringAppendF(&dump, match ? "[[" : "["); + dump += " "; + dump += match ? "[[" : "["; for (int b = 0; b < prog->bytemap_range() + 1; b++) - StringAppendF(&dump, "%d,", next[b]); + dump += StringPrintf("%d,", next[b]); dump.pop_back(); - StringAppendF(&dump, match ? "]]" : "]"); + dump += match ? "]]" : "]"; }); if (dump != t.dump) { LOG(ERROR) << t.regexp << " bytemap:\n" << prog->DumpByteMap(); diff --git a/re2/testing/dump.cc b/re2/testing/dump.cc index 743f7b5..1df8ddd 100644 --- a/re2/testing/dump.cc +++ b/re2/testing/dump.cc @@ -59,7 +59,7 @@ static const char* kOpcodeNames[] = { // Nothing pretty, just for testing. static void DumpRegexpAppending(Regexp* re, std::string* s) { if (re->op() < 0 || re->op() >= arraysize(kOpcodeNames)) { - StringAppendF(s, "op%d", re->op()); + *s += StringPrintf("op%d", re->op()); } else { switch (re->op()) { default: diff --git a/re2/testing/exhaustive_tester.cc b/re2/testing/exhaustive_tester.cc index 7e5dd14..47950ba 100644 --- a/re2/testing/exhaustive_tester.cc +++ b/re2/testing/exhaustive_tester.cc @@ -174,7 +174,7 @@ void EgrepTest(int maxatoms, int maxops, const std::string& alphabet, const std::string& wrapper) { const char* tops[] = { "", "^(?:%s)", "(?:%s)$", "^(?:%s)$" }; - for (int i = 0; i < arraysize(tops); i++) { + for (size_t i = 0; i < arraysize(tops); i++) { ExhaustiveTest(maxatoms, maxops, Split("", alphabet), RegexpGenerator::EgrepOps(), diff --git a/re2/testing/filtered_re2_test.cc b/re2/testing/filtered_re2_test.cc index 835ebcf..deef2f8 100644 --- a/re2/testing/filtered_re2_test.cc +++ b/re2/testing/filtered_re2_test.cc @@ -144,9 +144,9 @@ AtomTest atom_tests[] = { }; void AddRegexpsAndCompile(const char* regexps[], - int n, + size_t n, struct FilterTestVars* v) { - for (int i = 0; i < n; i++) { + for (size_t i = 0; i < n; i++) { int id; v->f.Add(regexps[i], v->opts, &id); } @@ -154,18 +154,18 @@ void AddRegexpsAndCompile(const char* regexps[], } bool CheckExpectedAtoms(const char* atoms[], - int n, + size_t n, const char* testname, struct FilterTestVars* v) { std::vector expected; - for (int i = 0; i < n; i++) + for (size_t i = 0; i < n; i++) expected.push_back(atoms[i]); bool pass = expected.size() == v->atoms.size(); std::sort(v->atoms.begin(), v->atoms.end()); std::sort(expected.begin(), expected.end()); - for (int i = 0; pass && i < n; i++) + for (size_t i = 0; pass && i < n; i++) pass = pass && expected[i] == v->atoms[i]; if (!pass) { @@ -183,10 +183,10 @@ bool CheckExpectedAtoms(const char* atoms[], TEST(FilteredRE2Test, AtomTests) { int nfail = 0; - for (int i = 0; i < arraysize(atom_tests); i++) { + for (size_t i = 0; i < arraysize(atom_tests); i++) { FilterTestVars v; AtomTest* t = &atom_tests[i]; - int natom, nregexp; + size_t nregexp, natom; for (nregexp = 0; nregexp < arraysize(t->regexps); nregexp++) if (t->regexps[nregexp] == NULL) break; @@ -221,7 +221,7 @@ TEST(FilteredRE2Test, MatchEmptyPattern) { // for this test. Adding the EXPECT here to make sure // the index we use for the test is for the correct test. EXPECT_EQ("CheckEmptyPattern", std::string(t->testname)); - int nregexp; + size_t nregexp; for (nregexp = 0; nregexp < arraysize(t->regexps); nregexp++) if (t->regexps[nregexp] == NULL) break; @@ -238,7 +238,7 @@ TEST(FilteredRE2Test, MatchTests) { // We are using the regexps used in one of the atom tests // for this test. EXPECT_EQ("SubstrAtomRemovesSuperStrInOr", std::string(t->testname)); - int nregexp; + size_t nregexp; for (nregexp = 0; nregexp < arraysize(t->regexps); nregexp++) if (t->regexps[nregexp] == NULL) break; @@ -277,4 +277,18 @@ TEST(FilteredRE2Test, MatchTests) { EXPECT_EQ(2, matching_regexps.size()); } +TEST(FilteredRE2Test, EmptyStringInStringSetBug) { + // Bug due to find() finding "" at the start of everything in a string + // set and thus SimplifyStringSet() would end up erasing everything. + // In order to test this, we have to keep PrefilterTree from discarding + // the OR entirely, so we have to make the minimum atom length zero. + + FilterTestVars v(0); // override the minimum atom length + const char* regexps[] = {"-R.+(|ADD=;AA){12}}"}; + const char* atoms[] = {"", "-r", "add=;aa", "}"}; + AddRegexpsAndCompile(regexps, arraysize(regexps), &v); + EXPECT_TRUE(CheckExpectedAtoms(atoms, arraysize(atoms), + "EmptyStringInStringSetBug", &v)); +} + } // namespace re2 diff --git a/re2/testing/mimics_pcre_test.cc b/re2/testing/mimics_pcre_test.cc index 2dbbfa1..01ab41e 100644 --- a/re2/testing/mimics_pcre_test.cc +++ b/re2/testing/mimics_pcre_test.cc @@ -58,9 +58,9 @@ static PCRETest tests[] = { }; TEST(MimicsPCRE, SimpleTests) { - for (int i = 0; i < arraysize(tests); i++) { + for (size_t i = 0; i < arraysize(tests); i++) { const PCRETest& t = tests[i]; - for (int j = 0; j < 2; j++) { + for (size_t j = 0; j < 2; j++) { Regexp::ParseFlags flags = Regexp::LikePerl; if (j == 0) flags = flags | Regexp::Latin1; @@ -68,7 +68,7 @@ TEST(MimicsPCRE, SimpleTests) { ASSERT_TRUE(re != NULL) << " " << t.regexp; ASSERT_EQ(t.should_match, re->MimicsPCRE()) << " " << t.regexp << " " - << (j==0 ? "latin1" : "utf"); + << (j == 0 ? "latin1" : "utf"); re->Decref(); } } diff --git a/re2/testing/parse_test.cc b/re2/testing/parse_test.cc index a3289b9..3446526 100644 --- a/re2/testing/parse_test.cc +++ b/re2/testing/parse_test.cc @@ -427,20 +427,20 @@ const char* only_posix[] = { // Test that parser rejects bad regexps. TEST(TestParse, InvalidRegexps) { - for (int i = 0; i < arraysize(badtests); i++) { + for (size_t i = 0; i < arraysize(badtests); i++) { ASSERT_TRUE(Regexp::Parse(badtests[i], Regexp::PerlX, NULL) == NULL) << " " << badtests[i]; ASSERT_TRUE(Regexp::Parse(badtests[i], Regexp::NoParseFlags, NULL) == NULL) << " " << badtests[i]; } - for (int i = 0; i < arraysize(only_posix); i++) { + for (size_t i = 0; i < arraysize(only_posix); i++) { ASSERT_TRUE(Regexp::Parse(only_posix[i], Regexp::PerlX, NULL) == NULL) << " " << only_posix[i]; Regexp* re = Regexp::Parse(only_posix[i], Regexp::NoParseFlags, NULL); ASSERT_TRUE(re != NULL) << " " << only_posix[i]; re->Decref(); } - for (int i = 0; i < arraysize(only_perl); i++) { + for (size_t i = 0; i < arraysize(only_perl); i++) { ASSERT_TRUE(Regexp::Parse(only_perl[i], Regexp::NoParseFlags, NULL) == NULL) << " " << only_perl[i]; Regexp* re = Regexp::Parse(only_perl[i], Regexp::PerlX, NULL); @@ -451,7 +451,7 @@ TEST(TestParse, InvalidRegexps) { // Test that ToString produces original regexp or equivalent one. TEST(TestToString, EquivalentParse) { - for (int i = 0; i < arraysize(tests); i++) { + for (size_t i = 0; i < arraysize(tests); i++) { RegexpStatus status; Regexp::ParseFlags f = kTestFlags; if (tests[i].flags != 0) { diff --git a/re2/testing/possible_match_test.cc b/re2/testing/possible_match_test.cc index 438cb41..0ec90ae 100644 --- a/re2/testing/possible_match_test.cc +++ b/re2/testing/possible_match_test.cc @@ -107,8 +107,8 @@ static PrefixTest tests[] = { }; TEST(PossibleMatchRange, HandWritten) { - for (int i = 0; i < arraysize(tests); i++) { - for (int j = 0; j < 2; j++) { + for (size_t i = 0; i < arraysize(tests); i++) { + for (size_t j = 0; j < 2; j++) { const PrefixTest& t = tests[i]; std::string min, max; if (j == 0) { diff --git a/re2/testing/re2_test.cc b/re2/testing/re2_test.cc index 52c9294..2f4b90c 100644 --- a/re2/testing/re2_test.cc +++ b/re2/testing/re2_test.cc @@ -519,7 +519,7 @@ TEST(EmptyCharset, Fuzz) { "[^\\D\\d]", "[^\\D[:digit:]]" }; - for (int i = 0; i < arraysize(empties); i++) + for (size_t i = 0; i < arraysize(empties); i++) ASSERT_FALSE(RE2(empties[i]).Match("abc", 0, 3, RE2::UNANCHORED, NULL, 0)); } @@ -534,7 +534,7 @@ TEST(EmptyCharset, BitstateAssumptions) { "((((()))))" "(([^\\S\\s]|[^\\S\\s])|)" }; StringPiece group[6]; - for (int i = 0; i < arraysize(nop_empties); i++) + for (size_t i = 0; i < arraysize(nop_empties); i++) ASSERT_TRUE(RE2(nop_empties[i]).Match("", 0, 0, RE2::UNANCHORED, group, 6)); } @@ -1297,7 +1297,7 @@ static struct ErrorTest { { "zz(?Pabc)", "" }, }; TEST(RE2, ErrorArgs) { - for (int i = 0; i < arraysize(error_tests); i++) { + for (size_t i = 0; i < arraysize(error_tests); i++) { RE2 re(error_tests[i].regexp, RE2::Quiet); EXPECT_FALSE(re.ok()); EXPECT_EQ(re.error_arg(), error_tests[i].error) << re.error(); @@ -1319,7 +1319,7 @@ static struct NeverTest { TEST(RE2, NeverNewline) { RE2::Options opt; opt.set_never_nl(true); - for (int i = 0; i < arraysize(never_tests); i++) { + for (size_t i = 0; i < arraysize(never_tests); i++) { const NeverTest& t = never_tests[i]; RE2 re(t.regexp, opt); if (t.match == NULL) { @@ -1454,18 +1454,18 @@ TEST(RE2, NullVsEmptyStringSubmatches) { // matches[0] is overall match, [1] is (), [2] is (foo), [3] is nonexistent. StringPiece matches[4]; - for (int i = 0; i < arraysize(matches); i++) + for (size_t i = 0; i < arraysize(matches); i++) matches[i] = "bar"; StringPiece null; EXPECT_TRUE(re.Match(null, 0, null.size(), RE2::UNANCHORED, matches, arraysize(matches))); - for (int i = 0; i < arraysize(matches); i++) { + for (size_t i = 0; i < arraysize(matches); i++) { EXPECT_TRUE(matches[i].data() == NULL); // always null EXPECT_TRUE(matches[i].empty()); } - for (int i = 0; i < arraysize(matches); i++) + for (size_t i = 0; i < arraysize(matches); i++) matches[i] = "bar"; StringPiece empty(""); diff --git a/re2/testing/required_prefix_test.cc b/re2/testing/required_prefix_test.cc index 749c5ad..5460045 100644 --- a/re2/testing/required_prefix_test.cc +++ b/re2/testing/required_prefix_test.cc @@ -40,9 +40,9 @@ static PrefixTest tests[] = { }; TEST(RequiredPrefix, SimpleTests) { - for (int i = 0; i < arraysize(tests); i++) { + for (size_t i = 0; i < arraysize(tests); i++) { const PrefixTest& t = tests[i]; - for (int j = 0; j < 2; j++) { + for (size_t j = 0; j < 2; j++) { Regexp::ParseFlags flags = Regexp::LikePerl; if (j == 0) flags = flags | Regexp::Latin1; @@ -53,15 +53,15 @@ TEST(RequiredPrefix, SimpleTests) { bool f; Regexp* s; ASSERT_EQ(t.return_value, re->RequiredPrefix(&p, &f, &s)) - << " " << t.regexp << " " << (j==0 ? "latin1" : "utf") + << " " << t.regexp << " " << (j == 0 ? "latin1" : "utf") << " " << re->Dump(); if (t.return_value) { ASSERT_EQ(p, std::string(t.prefix)) - << " " << t.regexp << " " << (j==0 ? "latin1" : "utf"); + << " " << t.regexp << " " << (j == 0 ? "latin1" : "utf"); ASSERT_EQ(f, t.foldcase) - << " " << t.regexp << " " << (j==0 ? "latin1" : "utf"); + << " " << t.regexp << " " << (j == 0 ? "latin1" : "utf"); ASSERT_EQ(s->ToString(), std::string(t.suffix)) - << " " << t.regexp << " " << (j==0 ? "latin1" : "utf"); + << " " << t.regexp << " " << (j == 0 ? "latin1" : "utf"); s->Decref(); } re->Decref(); diff --git a/re2/testing/search_test.cc b/re2/testing/search_test.cc index 43a3952..c20f501 100644 --- a/re2/testing/search_test.cc +++ b/re2/testing/search_test.cc @@ -312,7 +312,7 @@ RegexpTest simple_tests[] = { TEST(Regexp, SearchTests) { int failures = 0; - for (int i = 0; i < arraysize(simple_tests); i++) { + for (size_t i = 0; i < arraysize(simple_tests); i++) { const RegexpTest& t = simple_tests[i]; if (!TestRegexpOnText(t.regexp, t.text)) failures++; diff --git a/re2/testing/simplify_test.cc b/re2/testing/simplify_test.cc index ede0f32..9dcd4ac 100644 --- a/re2/testing/simplify_test.cc +++ b/re2/testing/simplify_test.cc @@ -245,7 +245,7 @@ static Test tests[] = { }; TEST(TestSimplify, SimpleRegexps) { - for (int i = 0; i < arraysize(tests); i++) { + for (size_t i = 0; i < arraysize(tests); i++) { RegexpStatus status; VLOG(1) << "Testing " << tests[i].regexp; Regexp* re = Regexp::Parse(tests[i].regexp, diff --git a/re2/testing/tester.cc b/re2/testing/tester.cc index 92b5972..d676d9a 100644 --- a/re2/testing/tester.cc +++ b/re2/testing/tester.cc @@ -158,7 +158,7 @@ static ParseMode parse_modes[] = { }; static std::string FormatMode(Regexp::ParseFlags flags) { - for (int i = 0; i < arraysize(parse_modes); i++) + for (size_t i = 0; i < arraysize(parse_modes); i++) if (parse_modes[i].parse_flags == flags) return parse_modes[i].desc; return StringPrintf("%#x", static_cast(flags)); @@ -610,8 +610,8 @@ static Prog::MatchKind kinds[] = { // Test all possible match kinds and parse modes. Tester::Tester(const StringPiece& regexp) { error_ = false; - for (int i = 0; i < arraysize(kinds); i++) { - for (int j = 0; j < arraysize(parse_modes); j++) { + for (size_t i = 0; i < arraysize(kinds); i++) { + for (size_t j = 0; j < arraysize(parse_modes); j++) { TestInstance* t = new TestInstance(regexp, kinds[i], parse_modes[j].parse_flags); error_ |= t->error(); @@ -655,7 +655,7 @@ bool Tester::TestInput(const StringPiece& text) { bool Tester::TestInputInContext(const StringPiece& text, const StringPiece& context) { bool okay = true; - for (int i = 0; i < arraysize(anchors); i++) + for (size_t i = 0; i < arraysize(anchors); i++) okay &= TestCase(text, context, anchors[i]); return okay; } diff --git a/re2/tostring.cc b/re2/tostring.cc index a608c87..4545a92 100644 --- a/re2/tostring.cc +++ b/re2/tostring.cc @@ -332,10 +332,10 @@ static void AppendCCChar(std::string* t, Rune r) { } if (r < 0x100) { - StringAppendF(t, "\\x%02x", static_cast(r)); + *t += StringPrintf("\\x%02x", static_cast(r)); return; } - StringAppendF(t, "\\x{%x}", static_cast(r)); + *t += StringPrintf("\\x{%x}", static_cast(r)); } static void AppendCCRange(std::string* t, Rune lo, Rune hi) { diff --git a/re2/unicode.py b/re2/unicode.py index deff4d8..56ca811 100644 --- a/re2/unicode.py +++ b/re2/unicode.py @@ -4,12 +4,16 @@ """Parser for Unicode data files (as distributed by unicode.org).""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + import os import re -import urllib2 +from six.moves import urllib # Directory or URL where Unicode tables reside. -_UNICODE_DIR = "https://www.unicode.org/Public/11.0.0/ucd" +_UNICODE_DIR = "https://www.unicode.org/Public/12.1.0/ucd" # Largest valid Unicode code value. _RUNE_MAX = 0x10FFFF @@ -149,9 +153,9 @@ def ReadUnicodeTable(filename, nfields, doline): if type(filename) == str: if filename.startswith("https://"): - fil = urllib2.urlopen(filename) + fil = urllib.request.urlopen(filename) else: - fil = open(filename, "r") + fil = open(filename, "rb") else: fil = filename @@ -161,6 +165,8 @@ def ReadUnicodeTable(filename, nfields, doline): for line in fil: lineno += 1 try: + line = line.decode('latin1') + # Chop # comments and white space; ignore empty lines. sharp = line.find("#") if sharp >= 0: @@ -207,8 +213,8 @@ def ReadUnicodeTable(filename, nfields, doline): doline(codes, fields) - except Exception, e: - print "%s:%d: %s" % (filename, lineno, e) + except Exception as e: + print("%s:%d: %s" % (filename, lineno, e)) raise if expect_last is not None: @@ -243,7 +249,7 @@ def CaseGroups(unicode_dir=_UNICODE_DIR): ReadUnicodeTable(unicode_dir+"/CaseFolding.txt", 4, DoLine) - groups = togroup.values() + groups = list(togroup.values()) for g in groups: g.sort() groups.sort() diff --git a/re2/unicode_casefold.cc b/re2/unicode_casefold.cc index b4da09d..4ea2533 100644 --- a/re2/unicode_casefold.cc +++ b/re2/unicode_casefold.cc @@ -7,7 +7,7 @@ namespace re2 { -// 1374 groups, 2778 pairs, 349 ranges +// 1381 groups, 2792 pairs, 356 ranges const CaseFold unicode_casefold[] = { { 65, 90, 32 }, { 97, 106, -32 }, @@ -122,6 +122,7 @@ const CaseFold unicode_casefold[] = { { 629, 629, -214 }, { 637, 637, 10727 }, { 640, 640, -218 }, + { 642, 642, 42307 }, { 643, 643, -218 }, { 647, 647, 42282 }, { 648, 648, -218 }, @@ -228,6 +229,7 @@ const CaseFold unicode_casefold[] = { { 7357, 7359, -3008 }, { 7545, 7545, 35332 }, { 7549, 7549, 3814 }, + { 7566, 7566, 35384 }, { 7680, 7776, EvenOdd }, { 7777, 7777, 58 }, { 7778, 7829, EvenOdd }, @@ -331,6 +333,7 @@ const CaseFold unicode_casefold[] = { { 42891, 42892, OddEven }, { 42893, 42893, -42280 }, { 42896, 42899, EvenOdd }, + { 42900, 42900, 48 }, { 42902, 42921, EvenOdd }, { 42922, 42922, -42308 }, { 42923, 42923, -42319 }, @@ -341,7 +344,11 @@ const CaseFold unicode_casefold[] = { { 42929, 42929, -42282 }, { 42930, 42930, -42261 }, { 42931, 42931, 928 }, - { 42932, 42937, EvenOdd }, + { 42932, 42943, EvenOdd }, + { 42946, 42947, EvenOdd }, + { 42948, 42948, -48 }, + { 42949, 42949, -42307 }, + { 42950, 42950, -35384 }, { 43859, 43859, -928 }, { 43888, 43967, -38864 }, { 65313, 65338, 32 }, @@ -359,9 +366,9 @@ const CaseFold unicode_casefold[] = { { 125184, 125217, 34 }, { 125218, 125251, -34 }, }; -const int num_unicode_casefold = 349; +const int num_unicode_casefold = 356; -// 1374 groups, 1404 pairs, 194 ranges +// 1381 groups, 1411 pairs, 198 ranges const CaseFold unicode_tolower[] = { { 65, 90, 32 }, { 181, 181, 775 }, @@ -548,7 +555,11 @@ const CaseFold unicode_tolower[] = { { 42929, 42929, -42282 }, { 42930, 42930, -42261 }, { 42931, 42931, 928 }, - { 42932, 42936, EvenOddSkip }, + { 42932, 42942, EvenOddSkip }, + { 42946, 42946, EvenOdd }, + { 42948, 42948, -48 }, + { 42949, 42949, -42307 }, + { 42950, 42950, -35384 }, { 43888, 43967, -38864 }, { 65313, 65338, 32 }, { 66560, 66599, 40 }, @@ -558,7 +569,7 @@ const CaseFold unicode_tolower[] = { { 93760, 93791, 32 }, { 125184, 125217, 34 }, }; -const int num_unicode_tolower = 194; +const int num_unicode_tolower = 198; diff --git a/re2/unicode_groups.cc b/re2/unicode_groups.cc index 8052827..63e6116 100644 --- a/re2/unicode_groups.cc +++ b/re2/unicode_groups.cc @@ -7,183 +7,107 @@ namespace re2 { -static const URange16 Ps_range16[] = { - { 40, 40 }, - { 91, 91 }, - { 123, 123 }, - { 3898, 3898 }, - { 3900, 3900 }, - { 5787, 5787 }, - { 8218, 8218 }, - { 8222, 8222 }, - { 8261, 8261 }, - { 8317, 8317 }, - { 8333, 8333 }, - { 8968, 8968 }, - { 8970, 8970 }, - { 9001, 9001 }, - { 10088, 10088 }, - { 10090, 10090 }, - { 10092, 10092 }, - { 10094, 10094 }, - { 10096, 10096 }, - { 10098, 10098 }, - { 10100, 10100 }, - { 10181, 10181 }, - { 10214, 10214 }, - { 10216, 10216 }, - { 10218, 10218 }, - { 10220, 10220 }, - { 10222, 10222 }, - { 10627, 10627 }, - { 10629, 10629 }, - { 10631, 10631 }, - { 10633, 10633 }, - { 10635, 10635 }, - { 10637, 10637 }, - { 10639, 10639 }, - { 10641, 10641 }, - { 10643, 10643 }, - { 10645, 10645 }, - { 10647, 10647 }, - { 10712, 10712 }, - { 10714, 10714 }, - { 10748, 10748 }, - { 11810, 11810 }, - { 11812, 11812 }, - { 11814, 11814 }, - { 11816, 11816 }, - { 11842, 11842 }, - { 12296, 12296 }, - { 12298, 12298 }, - { 12300, 12300 }, - { 12302, 12302 }, - { 12304, 12304 }, - { 12308, 12308 }, - { 12310, 12310 }, - { 12312, 12312 }, - { 12314, 12314 }, - { 12317, 12317 }, - { 64831, 64831 }, - { 65047, 65047 }, - { 65077, 65077 }, - { 65079, 65079 }, - { 65081, 65081 }, - { 65083, 65083 }, - { 65085, 65085 }, - { 65087, 65087 }, - { 65089, 65089 }, - { 65091, 65091 }, - { 65095, 65095 }, - { 65113, 65113 }, - { 65115, 65115 }, - { 65117, 65117 }, - { 65288, 65288 }, - { 65339, 65339 }, - { 65371, 65371 }, - { 65375, 65375 }, - { 65378, 65378 }, +static const URange16 C_range16[] = { + { 0, 31 }, + { 127, 159 }, + { 173, 173 }, + { 1536, 1541 }, + { 1564, 1564 }, + { 1757, 1757 }, + { 1807, 1807 }, + { 2274, 2274 }, + { 6158, 6158 }, + { 8203, 8207 }, + { 8234, 8238 }, + { 8288, 8292 }, + { 8294, 8303 }, + { 55296, 63743 }, + { 65279, 65279 }, + { 65529, 65531 }, }; -static const URange16 Nl_range16[] = { - { 5870, 5872 }, - { 8544, 8578 }, - { 8581, 8584 }, - { 12295, 12295 }, - { 12321, 12329 }, - { 12344, 12346 }, - { 42726, 42735 }, +static const URange32 C_range32[] = { + { 69821, 69821 }, + { 69837, 69837 }, + { 78896, 78904 }, + { 113824, 113827 }, + { 119155, 119162 }, + { 917505, 917505 }, + { 917536, 917631 }, + { 983040, 1048573 }, + { 1048576, 1114109 }, }; -static const URange32 Nl_range32[] = { - { 65856, 65908 }, - { 66369, 66369 }, - { 66378, 66378 }, - { 66513, 66517 }, - { 74752, 74862 }, +static const URange16 Cc_range16[] = { + { 0, 31 }, + { 127, 159 }, }; -static const URange16 No_range16[] = { - { 178, 179 }, - { 185, 185 }, - { 188, 190 }, - { 2548, 2553 }, - { 2930, 2935 }, - { 3056, 3058 }, - { 3192, 3198 }, - { 3416, 3422 }, - { 3440, 3448 }, - { 3882, 3891 }, - { 4969, 4988 }, - { 6128, 6137 }, - { 6618, 6618 }, - { 8304, 8304 }, - { 8308, 8313 }, - { 8320, 8329 }, - { 8528, 8543 }, - { 8585, 8585 }, - { 9312, 9371 }, - { 9450, 9471 }, - { 10102, 10131 }, - { 11517, 11517 }, - { 12690, 12693 }, - { 12832, 12841 }, - { 12872, 12879 }, - { 12881, 12895 }, - { 12928, 12937 }, - { 12977, 12991 }, - { 43056, 43061 }, +static const URange16 Cf_range16[] = { + { 173, 173 }, + { 1536, 1541 }, + { 1564, 1564 }, + { 1757, 1757 }, + { 1807, 1807 }, + { 2274, 2274 }, + { 6158, 6158 }, + { 8203, 8207 }, + { 8234, 8238 }, + { 8288, 8292 }, + { 8294, 8303 }, + { 65279, 65279 }, + { 65529, 65531 }, }; -static const URange32 No_range32[] = { - { 65799, 65843 }, - { 65909, 65912 }, - { 65930, 65931 }, - { 66273, 66299 }, - { 66336, 66339 }, - { 67672, 67679 }, - { 67705, 67711 }, - { 67751, 67759 }, - { 67835, 67839 }, - { 67862, 67867 }, - { 68028, 68029 }, - { 68032, 68047 }, - { 68050, 68095 }, - { 68160, 68168 }, - { 68221, 68222 }, - { 68253, 68255 }, - { 68331, 68335 }, - { 68440, 68447 }, - { 68472, 68479 }, - { 68521, 68527 }, - { 68858, 68863 }, - { 69216, 69246 }, - { 69405, 69414 }, - { 69457, 69460 }, - { 69714, 69733 }, - { 70113, 70132 }, - { 71482, 71483 }, - { 71914, 71922 }, - { 72794, 72812 }, - { 93019, 93025 }, - { 93824, 93846 }, - { 119520, 119539 }, - { 119648, 119672 }, - { 125127, 125135 }, - { 126065, 126123 }, - { 126125, 126127 }, - { 126129, 126132 }, - { 127232, 127244 }, +static const URange32 Cf_range32[] = { + { 69821, 69821 }, + { 69837, 69837 }, + { 78896, 78904 }, + { 113824, 113827 }, + { 119155, 119162 }, + { 917505, 917505 }, + { 917536, 917631 }, }; -static const URange16 Lo_range16[] = { +static const URange16 Co_range16[] = { + { 57344, 63743 }, +}; +static const URange32 Co_range32[] = { + { 983040, 1048573 }, + { 1048576, 1114109 }, +}; +static const URange16 Cs_range16[] = { + { 55296, 57343 }, +}; +static const URange16 L_range16[] = { + { 65, 90 }, + { 97, 122 }, { 170, 170 }, + { 181, 181 }, { 186, 186 }, - { 443, 443 }, - { 448, 451 }, - { 660, 660 }, + { 192, 214 }, + { 216, 246 }, + { 248, 705 }, + { 710, 721 }, + { 736, 740 }, + { 748, 748 }, + { 750, 750 }, + { 880, 884 }, + { 886, 887 }, + { 890, 893 }, + { 895, 895 }, + { 902, 902 }, + { 904, 906 }, + { 908, 908 }, + { 910, 929 }, + { 931, 1013 }, + { 1015, 1153 }, + { 1162, 1327 }, + { 1329, 1366 }, + { 1369, 1369 }, + { 1376, 1416 }, { 1488, 1514 }, { 1519, 1522 }, - { 1568, 1599 }, - { 1601, 1610 }, + { 1568, 1610 }, { 1646, 1647 }, { 1649, 1747 }, { 1749, 1749 }, + { 1765, 1766 }, { 1774, 1775 }, { 1786, 1788 }, { 1791, 1791 }, @@ -192,16 +116,21 @@ static const URange16 Lo_range16[] = { { 1869, 1957 }, { 1969, 1969 }, { 1994, 2026 }, + { 2036, 2037 }, + { 2042, 2042 }, { 2048, 2069 }, - { 2112, 2136 }, - { 2144, 2154 }, + { 2074, 2074 }, + { 2084, 2084 }, + { 2088, 2088 }, + { 2112, 2136 }, + { 2144, 2154 }, { 2208, 2228 }, { 2230, 2237 }, { 2308, 2361 }, { 2365, 2365 }, { 2384, 2384 }, { 2392, 2401 }, - { 2418, 2432 }, + { 2417, 2432 }, { 2437, 2444 }, { 2447, 2448 }, { 2451, 2472 }, @@ -287,22 +216,17 @@ static const URange16 Lo_range16[] = { { 3520, 3526 }, { 3585, 3632 }, { 3634, 3635 }, - { 3648, 3653 }, + { 3648, 3654 }, { 3713, 3714 }, { 3716, 3716 }, - { 3719, 3720 }, - { 3722, 3722 }, - { 3725, 3725 }, - { 3732, 3735 }, - { 3737, 3743 }, - { 3745, 3747 }, + { 3718, 3722 }, + { 3724, 3747 }, { 3749, 3749 }, - { 3751, 3751 }, - { 3754, 3755 }, - { 3757, 3760 }, + { 3751, 3760 }, { 3762, 3763 }, { 3773, 3773 }, { 3776, 3780 }, + { 3782, 3782 }, { 3804, 3807 }, { 3840, 3840 }, { 3904, 3911 }, @@ -317,7 +241,11 @@ static const URange16 Lo_range16[] = { { 4206, 4208 }, { 4213, 4225 }, { 4238, 4238 }, - { 4352, 4680 }, + { 4256, 4293 }, + { 4295, 4295 }, + { 4301, 4301 }, + { 4304, 4346 }, + { 4348, 4680 }, { 4682, 4685 }, { 4688, 4694 }, { 4696, 4696 }, @@ -334,6 +262,8 @@ static const URange16 Lo_range16[] = { { 4882, 4885 }, { 4888, 4954 }, { 4992, 5007 }, + { 5024, 5109 }, + { 5112, 5117 }, { 5121, 5740 }, { 5743, 5759 }, { 5761, 5786 }, @@ -346,9 +276,9 @@ static const URange16 Lo_range16[] = { { 5984, 5996 }, { 5998, 6000 }, { 6016, 6067 }, + { 6103, 6103 }, { 6108, 6108 }, - { 6176, 6210 }, - { 6212, 6264 }, + { 6176, 6264 }, { 6272, 6276 }, { 6279, 6312 }, { 6314, 6314 }, @@ -360,6 +290,7 @@ static const URange16 Lo_range16[] = { { 6576, 6601 }, { 6656, 6678 }, { 6688, 6740 }, + { 6823, 6823 }, { 6917, 6963 }, { 6981, 6987 }, { 7043, 7072 }, @@ -367,12 +298,61 @@ static const URange16 Lo_range16[] = { { 7098, 7141 }, { 7168, 7203 }, { 7245, 7247 }, - { 7258, 7287 }, + { 7258, 7293 }, + { 7296, 7304 }, + { 7312, 7354 }, + { 7357, 7359 }, { 7401, 7404 }, - { 7406, 7409 }, + { 7406, 7411 }, { 7413, 7414 }, - { 8501, 8504 }, + { 7418, 7418 }, + { 7424, 7615 }, + { 7680, 7957 }, + { 7960, 7965 }, + { 7968, 8005 }, + { 8008, 8013 }, + { 8016, 8023 }, + { 8025, 8025 }, + { 8027, 8027 }, + { 8029, 8029 }, + { 8031, 8061 }, + { 8064, 8116 }, + { 8118, 8124 }, + { 8126, 8126 }, + { 8130, 8132 }, + { 8134, 8140 }, + { 8144, 8147 }, + { 8150, 8155 }, + { 8160, 8172 }, + { 8178, 8180 }, + { 8182, 8188 }, + { 8305, 8305 }, + { 8319, 8319 }, + { 8336, 8348 }, + { 8450, 8450 }, + { 8455, 8455 }, + { 8458, 8467 }, + { 8469, 8469 }, + { 8473, 8477 }, + { 8484, 8484 }, + { 8486, 8486 }, + { 8488, 8488 }, + { 8490, 8493 }, + { 8495, 8505 }, + { 8508, 8511 }, + { 8517, 8521 }, + { 8526, 8526 }, + { 8579, 8580 }, + { 11264, 11310 }, + { 11312, 11358 }, + { 11360, 11492 }, + { 11499, 11502 }, + { 11506, 11507 }, + { 11520, 11557 }, + { 11559, 11559 }, + { 11565, 11565 }, { 11568, 11623 }, + { 11631, 11631 }, { 11648, 11670 }, { 11680, 11686 }, { 11688, 11694 }, @@ -382,29 +362,33 @@ static const URange16 Lo_range16[] = { { 11720, 11726 }, { 11728, 11734 }, { 11736, 11742 }, - { 12294, 12294 }, - { 12348, 12348 }, + { 11823, 11823 }, + { 12293, 12294 }, + { 12337, 12341 }, + { 12347, 12348 }, { 12353, 12438 }, - { 12447, 12447 }, + { 12445, 12447 }, { 12449, 12538 }, - { 12543, 12543 }, + { 12540, 12543 }, { 12549, 12591 }, { 12593, 12686 }, { 12704, 12730 }, { 12784, 12799 }, { 13312, 19893 }, { 19968, 40943 }, - { 40960, 40980 }, - { 40982, 42124 }, - { 42192, 42231 }, - { 42240, 42507 }, + { 40960, 42124 }, + { 42192, 42237 }, + { 42240, 42508 }, { 42512, 42527 }, { 42538, 42539 }, - { 42606, 42606 }, + { 42560, 42606 }, + { 42623, 42653 }, { 42656, 42725 }, - { 42895, 42895 }, - { 42999, 42999 }, - { 43003, 43009 }, + { 42775, 42783 }, + { 42786, 42888 }, + { 42891, 42943 }, + { 42946, 42950 }, + { 42999, 43009 }, { 43011, 43013 }, { 43015, 43018 }, { 43020, 43042 }, @@ -417,14 +401,14 @@ static const URange16 Lo_range16[] = { { 43312, 43334 }, { 43360, 43388 }, { 43396, 43442 }, + { 43471, 43471 }, { 43488, 43492 }, - { 43495, 43503 }, + { 43494, 43503 }, { 43514, 43518 }, { 43520, 43560 }, { 43584, 43586 }, { 43588, 43595 }, - { 43616, 43631 }, - { 43633, 43638 }, + { 43616, 43638 }, { 43642, 43642 }, { 43646, 43695 }, { 43697, 43697 }, @@ -432,20 +416,24 @@ static const URange16 Lo_range16[] = { { 43705, 43709 }, { 43712, 43712 }, { 43714, 43714 }, - { 43739, 43740 }, + { 43739, 43741 }, { 43744, 43754 }, - { 43762, 43762 }, + { 43762, 43764 }, { 43777, 43782 }, { 43785, 43790 }, { 43793, 43798 }, { 43808, 43814 }, { 43816, 43822 }, - { 43968, 44002 }, + { 43824, 43866 }, + { 43868, 43879 }, + { 43888, 44002 }, { 44032, 55203 }, { 55216, 55238 }, { 55243, 55291 }, { 63744, 64109 }, { 64112, 64217 }, + { 64256, 64262 }, + { 64275, 64279 }, { 64285, 64285 }, { 64287, 64296 }, { 64298, 64310 }, @@ -460,15 +448,15 @@ static const URange16 Lo_range16[] = { { 65008, 65019 }, { 65136, 65140 }, { 65142, 65276 }, - { 65382, 65391 }, - { 65393, 65437 }, - { 65440, 65470 }, + { 65313, 65338 }, + { 65345, 65370 }, + { 65382, 65470 }, { 65474, 65479 }, { 65482, 65487 }, { 65490, 65495 }, { 65498, 65500 }, }; -static const URange32 Lo_range32[] = { +static const URange32 L_range32[] = { { 65536, 65547 }, { 65549, 65574 }, { 65576, 65594 }, @@ -485,7 +473,9 @@ static const URange32 Lo_range32[] = { { 66432, 66461 }, { 66464, 66499 }, { 66504, 66511 }, - { 66640, 66717 }, + { 66560, 66717 }, + { 66736, 66771 }, + { 66776, 66811 }, { 66816, 66855 }, { 66864, 66915 }, { 67072, 67382 }, @@ -518,10 +508,13 @@ static const URange32 Lo_range32[] = { { 68448, 68466 }, { 68480, 68497 }, { 68608, 68680 }, + { 68736, 68786 }, + { 68800, 68850 }, { 68864, 68899 }, { 69376, 69404 }, { 69415, 69415 }, { 69424, 69445 }, + { 69600, 69622 }, { 69635, 69687 }, { 69763, 69807 }, { 69840, 69864 }, @@ -552,6 +545,7 @@ static const URange32 Lo_range32[] = { { 70493, 70497 }, { 70656, 70708 }, { 70727, 70730 }, + { 70751, 70751 }, { 70784, 70831 }, { 70852, 70853 }, { 70855, 70855 }, @@ -560,15 +554,20 @@ static const URange32 Lo_range32[] = { { 71168, 71215 }, { 71236, 71236 }, { 71296, 71338 }, + { 71352, 71352 }, { 71424, 71450 }, { 71680, 71723 }, + { 71840, 71903 }, { 71935, 71935 }, + { 72096, 72103 }, + { 72106, 72144 }, + { 72161, 72161 }, + { 72163, 72163 }, { 72192, 72192 }, { 72203, 72242 }, { 72250, 72250 }, { 72272, 72272 }, - { 72284, 72323 }, - { 72326, 72329 }, + { 72284, 72329 }, { 72349, 72349 }, { 72384, 72440 }, { 72704, 72712 }, @@ -592,19 +591,62 @@ static const URange32 Lo_range32[] = { { 92736, 92766 }, { 92880, 92909 }, { 92928, 92975 }, + { 92992, 92995 }, { 93027, 93047 }, { 93053, 93071 }, - { 93952, 94020 }, + { 93760, 93823 }, + { 93952, 94026 }, { 94032, 94032 }, - { 94208, 100337 }, + { 94099, 94111 }, + { 94176, 94177 }, + { 94179, 94179 }, + { 94208, 100343 }, { 100352, 101106 }, { 110592, 110878 }, + { 110928, 110930 }, + { 110948, 110951 }, { 110960, 111355 }, { 113664, 113770 }, { 113776, 113788 }, { 113792, 113800 }, { 113808, 113817 }, + { 119808, 119892 }, + { 119894, 119964 }, + { 119966, 119967 }, + { 119970, 119970 }, + { 119973, 119974 }, + { 119977, 119980 }, + { 119982, 119993 }, + { 119995, 119995 }, + { 119997, 120003 }, + { 120005, 120069 }, + { 120071, 120074 }, + { 120077, 120084 }, + { 120086, 120092 }, + { 120094, 120121 }, + { 120123, 120126 }, + { 120128, 120132 }, + { 120134, 120134 }, + { 120138, 120144 }, + { 120146, 120485 }, + { 120488, 120512 }, + { 120514, 120538 }, + { 120540, 120570 }, + { 120572, 120596 }, + { 120598, 120628 }, + { 120630, 120654 }, + { 120656, 120686 }, + { 120688, 120712 }, + { 120714, 120744 }, + { 120746, 120770 }, + { 120772, 120779 }, + { 123136, 123180 }, + { 123191, 123197 }, + { 123214, 123214 }, + { 123584, 123627 }, { 124928, 125124 }, + { 125184, 125251 }, + { 125259, 125259 }, { 126464, 126467 }, { 126469, 126495 }, { 126497, 126498 }, @@ -1243,9 +1285,13 @@ static const URange16 Ll_range16[] = { { 42933, 42933 }, { 42935, 42935 }, { 42937, 42937 }, + { 42939, 42939 }, + { 42941, 42941 }, + { 42943, 42943 }, + { 42947, 42947 }, { 43002, 43002 }, { 43824, 43866 }, - { 43872, 43877 }, + { 43872, 43879 }, { 43888, 43967 }, { 64256, 64262 }, { 64275, 64279 }, @@ -1347,2607 +1393,2543 @@ static const URange32 Lm_range32[] = { { 92992, 92995 }, { 94099, 94111 }, { 94176, 94177 }, + { 94179, 94179 }, + { 123191, 123197 }, + { 125259, 125259 }, }; -static const URange16 Nd_range16[] = { - { 48, 57 }, - { 1632, 1641 }, - { 1776, 1785 }, - { 1984, 1993 }, - { 2406, 2415 }, - { 2534, 2543 }, - { 2662, 2671 }, - { 2790, 2799 }, - { 2918, 2927 }, - { 3046, 3055 }, - { 3174, 3183 }, - { 3302, 3311 }, - { 3430, 3439 }, - { 3558, 3567 }, - { 3664, 3673 }, - { 3792, 3801 }, - { 3872, 3881 }, - { 4160, 4169 }, - { 4240, 4249 }, - { 6112, 6121 }, - { 6160, 6169 }, - { 6470, 6479 }, - { 6608, 6617 }, - { 6784, 6793 }, - { 6800, 6809 }, - { 6992, 7001 }, - { 7088, 7097 }, - { 7232, 7241 }, - { 7248, 7257 }, - { 42528, 42537 }, - { 43216, 43225 }, - { 43264, 43273 }, - { 43472, 43481 }, - { 43504, 43513 }, - { 43600, 43609 }, - { 44016, 44025 }, - { 65296, 65305 }, -}; -static const URange32 Nd_range32[] = { - { 66720, 66729 }, - { 68912, 68921 }, - { 69734, 69743 }, - { 69872, 69881 }, - { 69942, 69951 }, - { 70096, 70105 }, - { 70384, 70393 }, - { 70736, 70745 }, - { 70864, 70873 }, - { 71248, 71257 }, - { 71360, 71369 }, - { 71472, 71481 }, - { 71904, 71913 }, - { 72784, 72793 }, - { 73040, 73049 }, - { 73120, 73129 }, - { 92768, 92777 }, - { 93008, 93017 }, - { 120782, 120831 }, - { 125264, 125273 }, -}; -static const URange16 Pc_range16[] = { - { 95, 95 }, - { 8255, 8256 }, - { 8276, 8276 }, - { 65075, 65076 }, - { 65101, 65103 }, - { 65343, 65343 }, -}; -static const URange16 Lt_range16[] = { - { 453, 453 }, - { 456, 456 }, - { 459, 459 }, - { 498, 498 }, - { 8072, 8079 }, - { 8088, 8095 }, - { 8104, 8111 }, - { 8124, 8124 }, - { 8140, 8140 }, - { 8188, 8188 }, -}; -static const URange16 Lu_range16[] = { - { 65, 90 }, - { 192, 214 }, - { 216, 222 }, - { 256, 256 }, - { 258, 258 }, - { 260, 260 }, - { 262, 262 }, - { 264, 264 }, - { 266, 266 }, - { 268, 268 }, - { 270, 270 }, - { 272, 272 }, - { 274, 274 }, - { 276, 276 }, - { 278, 278 }, - { 280, 280 }, - { 282, 282 }, - { 284, 284 }, - { 286, 286 }, - { 288, 288 }, - { 290, 290 }, - { 292, 292 }, - { 294, 294 }, - { 296, 296 }, - { 298, 298 }, - { 300, 300 }, - { 302, 302 }, - { 304, 304 }, - { 306, 306 }, - { 308, 308 }, - { 310, 310 }, - { 313, 313 }, - { 315, 315 }, - { 317, 317 }, - { 319, 319 }, - { 321, 321 }, - { 323, 323 }, - { 325, 325 }, - { 327, 327 }, - { 330, 330 }, - { 332, 332 }, - { 334, 334 }, - { 336, 336 }, - { 338, 338 }, - { 340, 340 }, - { 342, 342 }, - { 344, 344 }, - { 346, 346 }, - { 348, 348 }, - { 350, 350 }, - { 352, 352 }, - { 354, 354 }, - { 356, 356 }, - { 358, 358 }, - { 360, 360 }, - { 362, 362 }, - { 364, 364 }, - { 366, 366 }, - { 368, 368 }, - { 370, 370 }, - { 372, 372 }, - { 374, 374 }, - { 376, 377 }, - { 379, 379 }, - { 381, 381 }, - { 385, 386 }, - { 388, 388 }, - { 390, 391 }, - { 393, 395 }, - { 398, 401 }, - { 403, 404 }, - { 406, 408 }, - { 412, 413 }, - { 415, 416 }, - { 418, 418 }, - { 420, 420 }, - { 422, 423 }, - { 425, 425 }, - { 428, 428 }, - { 430, 431 }, - { 433, 435 }, - { 437, 437 }, - { 439, 440 }, - { 444, 444 }, - { 452, 452 }, - { 455, 455 }, - { 458, 458 }, - { 461, 461 }, - { 463, 463 }, - { 465, 465 }, - { 467, 467 }, - { 469, 469 }, - { 471, 471 }, - { 473, 473 }, - { 475, 475 }, - { 478, 478 }, - { 480, 480 }, - { 482, 482 }, - { 484, 484 }, - { 486, 486 }, - { 488, 488 }, - { 490, 490 }, - { 492, 492 }, - { 494, 494 }, - { 497, 497 }, - { 500, 500 }, - { 502, 504 }, - { 506, 506 }, - { 508, 508 }, - { 510, 510 }, - { 512, 512 }, - { 514, 514 }, - { 516, 516 }, - { 518, 518 }, - { 520, 520 }, - { 522, 522 }, - { 524, 524 }, - { 526, 526 }, - { 528, 528 }, - { 530, 530 }, - { 532, 532 }, - { 534, 534 }, - { 536, 536 }, - { 538, 538 }, - { 540, 540 }, - { 542, 542 }, - { 544, 544 }, - { 546, 546 }, - { 548, 548 }, - { 550, 550 }, - { 552, 552 }, - { 554, 554 }, - { 556, 556 }, - { 558, 558 }, - { 560, 560 }, - { 562, 562 }, - { 570, 571 }, - { 573, 574 }, - { 577, 577 }, - { 579, 582 }, - { 584, 584 }, - { 586, 586 }, - { 588, 588 }, - { 590, 590 }, - { 880, 880 }, - { 882, 882 }, - { 886, 886 }, - { 895, 895 }, - { 902, 902 }, - { 904, 906 }, - { 908, 908 }, - { 910, 911 }, - { 913, 929 }, - { 931, 939 }, - { 975, 975 }, - { 978, 980 }, - { 984, 984 }, - { 986, 986 }, - { 988, 988 }, - { 990, 990 }, - { 992, 992 }, - { 994, 994 }, - { 996, 996 }, - { 998, 998 }, - { 1000, 1000 }, - { 1002, 1002 }, - { 1004, 1004 }, - { 1006, 1006 }, - { 1012, 1012 }, - { 1015, 1015 }, - { 1017, 1018 }, - { 1021, 1071 }, - { 1120, 1120 }, - { 1122, 1122 }, - { 1124, 1124 }, - { 1126, 1126 }, - { 1128, 1128 }, - { 1130, 1130 }, - { 1132, 1132 }, - { 1134, 1134 }, - { 1136, 1136 }, - { 1138, 1138 }, - { 1140, 1140 }, - { 1142, 1142 }, - { 1144, 1144 }, - { 1146, 1146 }, - { 1148, 1148 }, - { 1150, 1150 }, - { 1152, 1152 }, - { 1162, 1162 }, - { 1164, 1164 }, - { 1166, 1166 }, - { 1168, 1168 }, - { 1170, 1170 }, - { 1172, 1172 }, - { 1174, 1174 }, - { 1176, 1176 }, - { 1178, 1178 }, - { 1180, 1180 }, - { 1182, 1182 }, - { 1184, 1184 }, - { 1186, 1186 }, - { 1188, 1188 }, - { 1190, 1190 }, - { 1192, 1192 }, - { 1194, 1194 }, - { 1196, 1196 }, - { 1198, 1198 }, - { 1200, 1200 }, - { 1202, 1202 }, - { 1204, 1204 }, - { 1206, 1206 }, - { 1208, 1208 }, - { 1210, 1210 }, - { 1212, 1212 }, - { 1214, 1214 }, - { 1216, 1217 }, - { 1219, 1219 }, - { 1221, 1221 }, - { 1223, 1223 }, - { 1225, 1225 }, - { 1227, 1227 }, - { 1229, 1229 }, - { 1232, 1232 }, - { 1234, 1234 }, - { 1236, 1236 }, - { 1238, 1238 }, - { 1240, 1240 }, - { 1242, 1242 }, - { 1244, 1244 }, - { 1246, 1246 }, - { 1248, 1248 }, - { 1250, 1250 }, - { 1252, 1252 }, - { 1254, 1254 }, - { 1256, 1256 }, - { 1258, 1258 }, - { 1260, 1260 }, - { 1262, 1262 }, - { 1264, 1264 }, - { 1266, 1266 }, - { 1268, 1268 }, - { 1270, 1270 }, - { 1272, 1272 }, - { 1274, 1274 }, - { 1276, 1276 }, - { 1278, 1278 }, - { 1280, 1280 }, - { 1282, 1282 }, - { 1284, 1284 }, - { 1286, 1286 }, - { 1288, 1288 }, - { 1290, 1290 }, - { 1292, 1292 }, - { 1294, 1294 }, - { 1296, 1296 }, - { 1298, 1298 }, - { 1300, 1300 }, - { 1302, 1302 }, - { 1304, 1304 }, - { 1306, 1306 }, - { 1308, 1308 }, - { 1310, 1310 }, - { 1312, 1312 }, - { 1314, 1314 }, - { 1316, 1316 }, - { 1318, 1318 }, - { 1320, 1320 }, - { 1322, 1322 }, - { 1324, 1324 }, - { 1326, 1326 }, - { 1329, 1366 }, - { 4256, 4293 }, - { 4295, 4295 }, - { 4301, 4301 }, - { 5024, 5109 }, - { 7312, 7354 }, - { 7357, 7359 }, - { 7680, 7680 }, - { 7682, 7682 }, - { 7684, 7684 }, - { 7686, 7686 }, - { 7688, 7688 }, - { 7690, 7690 }, - { 7692, 7692 }, - { 7694, 7694 }, - { 7696, 7696 }, - { 7698, 7698 }, - { 7700, 7700 }, - { 7702, 7702 }, - { 7704, 7704 }, - { 7706, 7706 }, - { 7708, 7708 }, - { 7710, 7710 }, - { 7712, 7712 }, - { 7714, 7714 }, - { 7716, 7716 }, - { 7718, 7718 }, - { 7720, 7720 }, - { 7722, 7722 }, - { 7724, 7724 }, - { 7726, 7726 }, - { 7728, 7728 }, - { 7730, 7730 }, - { 7732, 7732 }, - { 7734, 7734 }, - { 7736, 7736 }, - { 7738, 7738 }, - { 7740, 7740 }, - { 7742, 7742 }, - { 7744, 7744 }, - { 7746, 7746 }, - { 7748, 7748 }, - { 7750, 7750 }, - { 7752, 7752 }, - { 7754, 7754 }, - { 7756, 7756 }, - { 7758, 7758 }, - { 7760, 7760 }, - { 7762, 7762 }, - { 7764, 7764 }, - { 7766, 7766 }, - { 7768, 7768 }, - { 7770, 7770 }, - { 7772, 7772 }, - { 7774, 7774 }, - { 7776, 7776 }, - { 7778, 7778 }, - { 7780, 7780 }, - { 7782, 7782 }, - { 7784, 7784 }, - { 7786, 7786 }, - { 7788, 7788 }, - { 7790, 7790 }, - { 7792, 7792 }, - { 7794, 7794 }, - { 7796, 7796 }, - { 7798, 7798 }, - { 7800, 7800 }, - { 7802, 7802 }, - { 7804, 7804 }, - { 7806, 7806 }, - { 7808, 7808 }, - { 7810, 7810 }, - { 7812, 7812 }, - { 7814, 7814 }, - { 7816, 7816 }, - { 7818, 7818 }, - { 7820, 7820 }, - { 7822, 7822 }, - { 7824, 7824 }, - { 7826, 7826 }, - { 7828, 7828 }, - { 7838, 7838 }, - { 7840, 7840 }, - { 7842, 7842 }, - { 7844, 7844 }, - { 7846, 7846 }, - { 7848, 7848 }, - { 7850, 7850 }, - { 7852, 7852 }, - { 7854, 7854 }, - { 7856, 7856 }, - { 7858, 7858 }, - { 7860, 7860 }, - { 7862, 7862 }, - { 7864, 7864 }, - { 7866, 7866 }, - { 7868, 7868 }, - { 7870, 7870 }, - { 7872, 7872 }, - { 7874, 7874 }, - { 7876, 7876 }, - { 7878, 7878 }, - { 7880, 7880 }, - { 7882, 7882 }, - { 7884, 7884 }, - { 7886, 7886 }, - { 7888, 7888 }, - { 7890, 7890 }, - { 7892, 7892 }, - { 7894, 7894 }, - { 7896, 7896 }, - { 7898, 7898 }, - { 7900, 7900 }, - { 7902, 7902 }, - { 7904, 7904 }, - { 7906, 7906 }, - { 7908, 7908 }, - { 7910, 7910 }, - { 7912, 7912 }, - { 7914, 7914 }, - { 7916, 7916 }, - { 7918, 7918 }, - { 7920, 7920 }, - { 7922, 7922 }, - { 7924, 7924 }, - { 7926, 7926 }, - { 7928, 7928 }, - { 7930, 7930 }, - { 7932, 7932 }, - { 7934, 7934 }, - { 7944, 7951 }, - { 7960, 7965 }, - { 7976, 7983 }, - { 7992, 7999 }, - { 8008, 8013 }, - { 8025, 8025 }, - { 8027, 8027 }, - { 8029, 8029 }, - { 8031, 8031 }, - { 8040, 8047 }, - { 8120, 8123 }, - { 8136, 8139 }, - { 8152, 8155 }, - { 8168, 8172 }, - { 8184, 8187 }, - { 8450, 8450 }, - { 8455, 8455 }, - { 8459, 8461 }, - { 8464, 8466 }, - { 8469, 8469 }, - { 8473, 8477 }, - { 8484, 8484 }, - { 8486, 8486 }, - { 8488, 8488 }, - { 8490, 8493 }, - { 8496, 8499 }, - { 8510, 8511 }, - { 8517, 8517 }, - { 8579, 8579 }, - { 11264, 11310 }, - { 11360, 11360 }, - { 11362, 11364 }, - { 11367, 11367 }, - { 11369, 11369 }, - { 11371, 11371 }, - { 11373, 11376 }, - { 11378, 11378 }, - { 11381, 11381 }, - { 11390, 11392 }, - { 11394, 11394 }, - { 11396, 11396 }, - { 11398, 11398 }, - { 11400, 11400 }, - { 11402, 11402 }, - { 11404, 11404 }, - { 11406, 11406 }, - { 11408, 11408 }, - { 11410, 11410 }, - { 11412, 11412 }, - { 11414, 11414 }, - { 11416, 11416 }, - { 11418, 11418 }, - { 11420, 11420 }, - { 11422, 11422 }, - { 11424, 11424 }, - { 11426, 11426 }, - { 11428, 11428 }, - { 11430, 11430 }, - { 11432, 11432 }, - { 11434, 11434 }, - { 11436, 11436 }, - { 11438, 11438 }, - { 11440, 11440 }, - { 11442, 11442 }, - { 11444, 11444 }, - { 11446, 11446 }, - { 11448, 11448 }, - { 11450, 11450 }, - { 11452, 11452 }, - { 11454, 11454 }, - { 11456, 11456 }, - { 11458, 11458 }, - { 11460, 11460 }, - { 11462, 11462 }, - { 11464, 11464 }, - { 11466, 11466 }, - { 11468, 11468 }, - { 11470, 11470 }, - { 11472, 11472 }, - { 11474, 11474 }, - { 11476, 11476 }, - { 11478, 11478 }, - { 11480, 11480 }, - { 11482, 11482 }, - { 11484, 11484 }, - { 11486, 11486 }, - { 11488, 11488 }, - { 11490, 11490 }, - { 11499, 11499 }, - { 11501, 11501 }, - { 11506, 11506 }, - { 42560, 42560 }, - { 42562, 42562 }, - { 42564, 42564 }, - { 42566, 42566 }, - { 42568, 42568 }, - { 42570, 42570 }, - { 42572, 42572 }, - { 42574, 42574 }, - { 42576, 42576 }, - { 42578, 42578 }, - { 42580, 42580 }, - { 42582, 42582 }, - { 42584, 42584 }, - { 42586, 42586 }, - { 42588, 42588 }, - { 42590, 42590 }, - { 42592, 42592 }, - { 42594, 42594 }, - { 42596, 42596 }, - { 42598, 42598 }, - { 42600, 42600 }, - { 42602, 42602 }, - { 42604, 42604 }, - { 42624, 42624 }, - { 42626, 42626 }, - { 42628, 42628 }, - { 42630, 42630 }, - { 42632, 42632 }, - { 42634, 42634 }, - { 42636, 42636 }, - { 42638, 42638 }, - { 42640, 42640 }, - { 42642, 42642 }, - { 42644, 42644 }, - { 42646, 42646 }, - { 42648, 42648 }, - { 42650, 42650 }, - { 42786, 42786 }, - { 42788, 42788 }, - { 42790, 42790 }, - { 42792, 42792 }, - { 42794, 42794 }, - { 42796, 42796 }, - { 42798, 42798 }, - { 42802, 42802 }, - { 42804, 42804 }, - { 42806, 42806 }, - { 42808, 42808 }, - { 42810, 42810 }, - { 42812, 42812 }, - { 42814, 42814 }, - { 42816, 42816 }, - { 42818, 42818 }, - { 42820, 42820 }, - { 42822, 42822 }, - { 42824, 42824 }, - { 42826, 42826 }, - { 42828, 42828 }, - { 42830, 42830 }, - { 42832, 42832 }, - { 42834, 42834 }, - { 42836, 42836 }, - { 42838, 42838 }, - { 42840, 42840 }, - { 42842, 42842 }, - { 42844, 42844 }, - { 42846, 42846 }, - { 42848, 42848 }, - { 42850, 42850 }, - { 42852, 42852 }, - { 42854, 42854 }, - { 42856, 42856 }, - { 42858, 42858 }, - { 42860, 42860 }, - { 42862, 42862 }, - { 42873, 42873 }, - { 42875, 42875 }, - { 42877, 42878 }, - { 42880, 42880 }, - { 42882, 42882 }, - { 42884, 42884 }, - { 42886, 42886 }, - { 42891, 42891 }, - { 42893, 42893 }, - { 42896, 42896 }, - { 42898, 42898 }, - { 42902, 42902 }, - { 42904, 42904 }, - { 42906, 42906 }, - { 42908, 42908 }, - { 42910, 42910 }, - { 42912, 42912 }, - { 42914, 42914 }, - { 42916, 42916 }, - { 42918, 42918 }, - { 42920, 42920 }, - { 42922, 42926 }, - { 42928, 42932 }, - { 42934, 42934 }, - { 42936, 42936 }, - { 65313, 65338 }, -}; -static const URange32 Lu_range32[] = { - { 66560, 66599 }, - { 66736, 66771 }, - { 68736, 68786 }, - { 71840, 71871 }, - { 93760, 93791 }, - { 119808, 119833 }, - { 119860, 119885 }, - { 119912, 119937 }, - { 119964, 119964 }, - { 119966, 119967 }, - { 119970, 119970 }, - { 119973, 119974 }, - { 119977, 119980 }, - { 119982, 119989 }, - { 120016, 120041 }, - { 120068, 120069 }, - { 120071, 120074 }, - { 120077, 120084 }, - { 120086, 120092 }, - { 120120, 120121 }, - { 120123, 120126 }, - { 120128, 120132 }, - { 120134, 120134 }, - { 120138, 120144 }, - { 120172, 120197 }, - { 120224, 120249 }, - { 120276, 120301 }, - { 120328, 120353 }, - { 120380, 120405 }, - { 120432, 120457 }, - { 120488, 120512 }, - { 120546, 120570 }, - { 120604, 120628 }, - { 120662, 120686 }, - { 120720, 120744 }, - { 120778, 120778 }, - { 125184, 125217 }, -}; -static const URange16 Pf_range16[] = { - { 187, 187 }, - { 8217, 8217 }, - { 8221, 8221 }, - { 8250, 8250 }, - { 11779, 11779 }, - { 11781, 11781 }, - { 11786, 11786 }, - { 11789, 11789 }, - { 11805, 11805 }, - { 11809, 11809 }, -}; -static const URange16 Pd_range16[] = { - { 45, 45 }, - { 1418, 1418 }, - { 1470, 1470 }, - { 5120, 5120 }, - { 6150, 6150 }, - { 8208, 8213 }, - { 11799, 11799 }, - { 11802, 11802 }, - { 11834, 11835 }, - { 11840, 11840 }, - { 12316, 12316 }, - { 12336, 12336 }, - { 12448, 12448 }, - { 65073, 65074 }, - { 65112, 65112 }, - { 65123, 65123 }, - { 65293, 65293 }, -}; -static const URange16 Pe_range16[] = { - { 41, 41 }, - { 93, 93 }, - { 125, 125 }, - { 3899, 3899 }, - { 3901, 3901 }, - { 5788, 5788 }, - { 8262, 8262 }, - { 8318, 8318 }, - { 8334, 8334 }, - { 8969, 8969 }, - { 8971, 8971 }, - { 9002, 9002 }, - { 10089, 10089 }, - { 10091, 10091 }, - { 10093, 10093 }, - { 10095, 10095 }, - { 10097, 10097 }, - { 10099, 10099 }, - { 10101, 10101 }, - { 10182, 10182 }, - { 10215, 10215 }, - { 10217, 10217 }, - { 10219, 10219 }, - { 10221, 10221 }, - { 10223, 10223 }, - { 10628, 10628 }, - { 10630, 10630 }, - { 10632, 10632 }, - { 10634, 10634 }, - { 10636, 10636 }, - { 10638, 10638 }, - { 10640, 10640 }, - { 10642, 10642 }, - { 10644, 10644 }, - { 10646, 10646 }, - { 10648, 10648 }, - { 10713, 10713 }, - { 10715, 10715 }, - { 10749, 10749 }, - { 11811, 11811 }, - { 11813, 11813 }, - { 11815, 11815 }, - { 11817, 11817 }, - { 12297, 12297 }, - { 12299, 12299 }, - { 12301, 12301 }, - { 12303, 12303 }, - { 12305, 12305 }, - { 12309, 12309 }, - { 12311, 12311 }, - { 12313, 12313 }, - { 12315, 12315 }, - { 12318, 12319 }, - { 64830, 64830 }, - { 65048, 65048 }, - { 65078, 65078 }, - { 65080, 65080 }, - { 65082, 65082 }, - { 65084, 65084 }, - { 65086, 65086 }, - { 65088, 65088 }, - { 65090, 65090 }, - { 65092, 65092 }, - { 65096, 65096 }, - { 65114, 65114 }, - { 65116, 65116 }, - { 65118, 65118 }, - { 65289, 65289 }, - { 65341, 65341 }, - { 65373, 65373 }, - { 65376, 65376 }, - { 65379, 65379 }, -}; -static const URange16 Pi_range16[] = { - { 171, 171 }, - { 8216, 8216 }, - { 8219, 8220 }, - { 8223, 8223 }, - { 8249, 8249 }, - { 11778, 11778 }, - { 11780, 11780 }, - { 11785, 11785 }, - { 11788, 11788 }, - { 11804, 11804 }, - { 11808, 11808 }, -}; -static const URange16 Po_range16[] = { - { 33, 35 }, - { 37, 39 }, - { 42, 42 }, - { 44, 44 }, - { 46, 47 }, - { 58, 59 }, - { 63, 64 }, - { 92, 92 }, - { 161, 161 }, - { 167, 167 }, - { 182, 183 }, - { 191, 191 }, - { 894, 894 }, - { 903, 903 }, - { 1370, 1375 }, - { 1417, 1417 }, - { 1472, 1472 }, - { 1475, 1475 }, - { 1478, 1478 }, - { 1523, 1524 }, - { 1545, 1546 }, - { 1548, 1549 }, - { 1563, 1563 }, - { 1566, 1567 }, - { 1642, 1645 }, - { 1748, 1748 }, - { 1792, 1805 }, - { 2039, 2041 }, - { 2096, 2110 }, - { 2142, 2142 }, - { 2404, 2405 }, - { 2416, 2416 }, - { 2557, 2557 }, - { 2678, 2678 }, - { 2800, 2800 }, - { 3204, 3204 }, - { 3572, 3572 }, - { 3663, 3663 }, - { 3674, 3675 }, - { 3844, 3858 }, - { 3860, 3860 }, - { 3973, 3973 }, - { 4048, 4052 }, - { 4057, 4058 }, - { 4170, 4175 }, - { 4347, 4347 }, - { 4960, 4968 }, - { 5741, 5742 }, - { 5867, 5869 }, - { 5941, 5942 }, - { 6100, 6102 }, - { 6104, 6106 }, - { 6144, 6149 }, - { 6151, 6154 }, - { 6468, 6469 }, - { 6686, 6687 }, - { 6816, 6822 }, - { 6824, 6829 }, - { 7002, 7008 }, - { 7164, 7167 }, - { 7227, 7231 }, - { 7294, 7295 }, - { 7360, 7367 }, - { 7379, 7379 }, - { 8214, 8215 }, - { 8224, 8231 }, - { 8240, 8248 }, - { 8251, 8254 }, - { 8257, 8259 }, - { 8263, 8273 }, - { 8275, 8275 }, - { 8277, 8286 }, - { 11513, 11516 }, - { 11518, 11519 }, - { 11632, 11632 }, - { 11776, 11777 }, - { 11782, 11784 }, - { 11787, 11787 }, - { 11790, 11798 }, - { 11800, 11801 }, - { 11803, 11803 }, - { 11806, 11807 }, - { 11818, 11822 }, - { 11824, 11833 }, - { 11836, 11839 }, - { 11841, 11841 }, - { 11843, 11854 }, - { 12289, 12291 }, - { 12349, 12349 }, - { 12539, 12539 }, - { 42238, 42239 }, - { 42509, 42511 }, - { 42611, 42611 }, - { 42622, 42622 }, - { 42738, 42743 }, - { 43124, 43127 }, - { 43214, 43215 }, - { 43256, 43258 }, - { 43260, 43260 }, - { 43310, 43311 }, - { 43359, 43359 }, - { 43457, 43469 }, - { 43486, 43487 }, - { 43612, 43615 }, - { 43742, 43743 }, - { 43760, 43761 }, - { 44011, 44011 }, - { 65040, 65046 }, - { 65049, 65049 }, - { 65072, 65072 }, - { 65093, 65094 }, - { 65097, 65100 }, - { 65104, 65106 }, - { 65108, 65111 }, - { 65119, 65121 }, - { 65128, 65128 }, - { 65130, 65131 }, - { 65281, 65283 }, - { 65285, 65287 }, - { 65290, 65290 }, - { 65292, 65292 }, - { 65294, 65295 }, - { 65306, 65307 }, - { 65311, 65312 }, - { 65340, 65340 }, - { 65377, 65377 }, - { 65380, 65381 }, -}; -static const URange32 Po_range32[] = { - { 65792, 65794 }, - { 66463, 66463 }, - { 66512, 66512 }, - { 66927, 66927 }, - { 67671, 67671 }, - { 67871, 67871 }, - { 67903, 67903 }, - { 68176, 68184 }, - { 68223, 68223 }, - { 68336, 68342 }, - { 68409, 68415 }, - { 68505, 68508 }, - { 69461, 69465 }, - { 69703, 69709 }, - { 69819, 69820 }, - { 69822, 69825 }, - { 69952, 69955 }, - { 70004, 70005 }, - { 70085, 70088 }, - { 70093, 70093 }, - { 70107, 70107 }, - { 70109, 70111 }, - { 70200, 70205 }, - { 70313, 70313 }, - { 70731, 70735 }, - { 70747, 70747 }, - { 70749, 70749 }, - { 70854, 70854 }, - { 71105, 71127 }, - { 71233, 71235 }, - { 71264, 71276 }, - { 71484, 71486 }, - { 71739, 71739 }, - { 72255, 72262 }, - { 72346, 72348 }, - { 72350, 72354 }, - { 72769, 72773 }, - { 72816, 72817 }, - { 73463, 73464 }, - { 74864, 74868 }, - { 92782, 92783 }, - { 92917, 92917 }, - { 92983, 92987 }, - { 92996, 92996 }, - { 93847, 93850 }, - { 113823, 113823 }, - { 121479, 121483 }, - { 125278, 125279 }, -}; -static const URange16 Me_range16[] = { - { 1160, 1161 }, - { 6846, 6846 }, - { 8413, 8416 }, - { 8418, 8420 }, - { 42608, 42610 }, -}; -static const URange16 C_range16[] = { - { 0, 31 }, - { 127, 159 }, - { 173, 173 }, - { 1536, 1541 }, - { 1564, 1564 }, - { 1757, 1757 }, - { 1807, 1807 }, - { 2274, 2274 }, - { 6158, 6158 }, - { 8203, 8207 }, - { 8234, 8238 }, - { 8288, 8292 }, - { 8294, 8303 }, - { 55296, 63743 }, - { 65279, 65279 }, - { 65529, 65531 }, -}; -static const URange32 C_range32[] = { - { 69821, 69821 }, - { 69837, 69837 }, - { 113824, 113827 }, - { 119155, 119162 }, - { 917505, 917505 }, - { 917536, 917631 }, - { 983040, 1048573 }, - { 1048576, 1114109 }, -}; -static const URange16 Mc_range16[] = { - { 2307, 2307 }, - { 2363, 2363 }, - { 2366, 2368 }, - { 2377, 2380 }, - { 2382, 2383 }, - { 2434, 2435 }, - { 2494, 2496 }, - { 2503, 2504 }, - { 2507, 2508 }, - { 2519, 2519 }, - { 2563, 2563 }, - { 2622, 2624 }, - { 2691, 2691 }, - { 2750, 2752 }, - { 2761, 2761 }, - { 2763, 2764 }, - { 2818, 2819 }, - { 2878, 2878 }, - { 2880, 2880 }, - { 2887, 2888 }, - { 2891, 2892 }, - { 2903, 2903 }, - { 3006, 3007 }, - { 3009, 3010 }, - { 3014, 3016 }, - { 3018, 3020 }, - { 3031, 3031 }, - { 3073, 3075 }, - { 3137, 3140 }, - { 3202, 3203 }, - { 3262, 3262 }, - { 3264, 3268 }, - { 3271, 3272 }, - { 3274, 3275 }, - { 3285, 3286 }, - { 3330, 3331 }, - { 3390, 3392 }, - { 3398, 3400 }, - { 3402, 3404 }, - { 3415, 3415 }, - { 3458, 3459 }, - { 3535, 3537 }, - { 3544, 3551 }, - { 3570, 3571 }, - { 3902, 3903 }, - { 3967, 3967 }, - { 4139, 4140 }, - { 4145, 4145 }, - { 4152, 4152 }, - { 4155, 4156 }, - { 4182, 4183 }, - { 4194, 4196 }, - { 4199, 4205 }, - { 4227, 4228 }, - { 4231, 4236 }, - { 4239, 4239 }, - { 4250, 4252 }, - { 6070, 6070 }, - { 6078, 6085 }, - { 6087, 6088 }, - { 6435, 6438 }, - { 6441, 6443 }, - { 6448, 6449 }, - { 6451, 6456 }, - { 6681, 6682 }, - { 6741, 6741 }, - { 6743, 6743 }, - { 6753, 6753 }, - { 6755, 6756 }, - { 6765, 6770 }, - { 6916, 6916 }, - { 6965, 6965 }, - { 6971, 6971 }, - { 6973, 6977 }, - { 6979, 6980 }, - { 7042, 7042 }, - { 7073, 7073 }, - { 7078, 7079 }, - { 7082, 7082 }, - { 7143, 7143 }, - { 7146, 7148 }, - { 7150, 7150 }, - { 7154, 7155 }, - { 7204, 7211 }, - { 7220, 7221 }, - { 7393, 7393 }, - { 7410, 7411 }, - { 7415, 7415 }, - { 12334, 12335 }, - { 43043, 43044 }, - { 43047, 43047 }, - { 43136, 43137 }, - { 43188, 43203 }, - { 43346, 43347 }, - { 43395, 43395 }, - { 43444, 43445 }, - { 43450, 43451 }, - { 43453, 43456 }, - { 43567, 43568 }, - { 43571, 43572 }, - { 43597, 43597 }, - { 43643, 43643 }, - { 43645, 43645 }, - { 43755, 43755 }, - { 43758, 43759 }, - { 43765, 43765 }, - { 44003, 44004 }, - { 44006, 44007 }, - { 44009, 44010 }, - { 44012, 44012 }, -}; -static const URange32 Mc_range32[] = { - { 69632, 69632 }, - { 69634, 69634 }, - { 69762, 69762 }, - { 69808, 69810 }, - { 69815, 69816 }, - { 69932, 69932 }, - { 69957, 69958 }, - { 70018, 70018 }, - { 70067, 70069 }, - { 70079, 70080 }, - { 70188, 70190 }, - { 70194, 70195 }, - { 70197, 70197 }, - { 70368, 70370 }, - { 70402, 70403 }, - { 70462, 70463 }, - { 70465, 70468 }, - { 70471, 70472 }, - { 70475, 70477 }, - { 70487, 70487 }, - { 70498, 70499 }, - { 70709, 70711 }, - { 70720, 70721 }, - { 70725, 70725 }, - { 70832, 70834 }, - { 70841, 70841 }, - { 70843, 70846 }, - { 70849, 70849 }, - { 71087, 71089 }, - { 71096, 71099 }, - { 71102, 71102 }, - { 71216, 71218 }, - { 71227, 71228 }, - { 71230, 71230 }, - { 71340, 71340 }, - { 71342, 71343 }, - { 71350, 71350 }, - { 71456, 71457 }, - { 71462, 71462 }, - { 71724, 71726 }, - { 71736, 71736 }, - { 72249, 72249 }, - { 72279, 72280 }, - { 72343, 72343 }, - { 72751, 72751 }, - { 72766, 72766 }, - { 72873, 72873 }, - { 72881, 72881 }, - { 72884, 72884 }, - { 73098, 73102 }, - { 73107, 73108 }, - { 73110, 73110 }, - { 73461, 73462 }, - { 94033, 94078 }, - { 119141, 119142 }, - { 119149, 119154 }, -}; -static const URange16 Mn_range16[] = { - { 768, 879 }, - { 1155, 1159 }, - { 1425, 1469 }, - { 1471, 1471 }, - { 1473, 1474 }, - { 1476, 1477 }, - { 1479, 1479 }, - { 1552, 1562 }, - { 1611, 1631 }, - { 1648, 1648 }, - { 1750, 1756 }, - { 1759, 1764 }, - { 1767, 1768 }, - { 1770, 1773 }, - { 1809, 1809 }, - { 1840, 1866 }, - { 1958, 1968 }, - { 2027, 2035 }, - { 2045, 2045 }, - { 2070, 2073 }, - { 2075, 2083 }, - { 2085, 2087 }, - { 2089, 2093 }, - { 2137, 2139 }, - { 2259, 2273 }, - { 2275, 2306 }, - { 2362, 2362 }, - { 2364, 2364 }, - { 2369, 2376 }, - { 2381, 2381 }, - { 2385, 2391 }, - { 2402, 2403 }, - { 2433, 2433 }, - { 2492, 2492 }, - { 2497, 2500 }, - { 2509, 2509 }, - { 2530, 2531 }, - { 2558, 2558 }, - { 2561, 2562 }, - { 2620, 2620 }, - { 2625, 2626 }, - { 2631, 2632 }, - { 2635, 2637 }, - { 2641, 2641 }, - { 2672, 2673 }, - { 2677, 2677 }, - { 2689, 2690 }, - { 2748, 2748 }, - { 2753, 2757 }, - { 2759, 2760 }, - { 2765, 2765 }, - { 2786, 2787 }, - { 2810, 2815 }, - { 2817, 2817 }, - { 2876, 2876 }, - { 2879, 2879 }, - { 2881, 2884 }, - { 2893, 2893 }, - { 2902, 2902 }, - { 2914, 2915 }, - { 2946, 2946 }, - { 3008, 3008 }, - { 3021, 3021 }, - { 3072, 3072 }, - { 3076, 3076 }, - { 3134, 3136 }, - { 3142, 3144 }, - { 3146, 3149 }, - { 3157, 3158 }, - { 3170, 3171 }, - { 3201, 3201 }, - { 3260, 3260 }, - { 3263, 3263 }, - { 3270, 3270 }, - { 3276, 3277 }, - { 3298, 3299 }, - { 3328, 3329 }, - { 3387, 3388 }, - { 3393, 3396 }, - { 3405, 3405 }, - { 3426, 3427 }, - { 3530, 3530 }, - { 3538, 3540 }, - { 3542, 3542 }, - { 3633, 3633 }, - { 3636, 3642 }, - { 3655, 3662 }, - { 3761, 3761 }, - { 3764, 3769 }, - { 3771, 3772 }, - { 3784, 3789 }, - { 3864, 3865 }, - { 3893, 3893 }, - { 3895, 3895 }, - { 3897, 3897 }, - { 3953, 3966 }, - { 3968, 3972 }, - { 3974, 3975 }, - { 3981, 3991 }, - { 3993, 4028 }, - { 4038, 4038 }, - { 4141, 4144 }, - { 4146, 4151 }, - { 4153, 4154 }, - { 4157, 4158 }, - { 4184, 4185 }, - { 4190, 4192 }, - { 4209, 4212 }, - { 4226, 4226 }, - { 4229, 4230 }, - { 4237, 4237 }, - { 4253, 4253 }, - { 4957, 4959 }, - { 5906, 5908 }, - { 5938, 5940 }, - { 5970, 5971 }, - { 6002, 6003 }, - { 6068, 6069 }, - { 6071, 6077 }, - { 6086, 6086 }, - { 6089, 6099 }, - { 6109, 6109 }, - { 6155, 6157 }, - { 6277, 6278 }, - { 6313, 6313 }, - { 6432, 6434 }, - { 6439, 6440 }, - { 6450, 6450 }, - { 6457, 6459 }, - { 6679, 6680 }, - { 6683, 6683 }, - { 6742, 6742 }, - { 6744, 6750 }, - { 6752, 6752 }, - { 6754, 6754 }, - { 6757, 6764 }, - { 6771, 6780 }, - { 6783, 6783 }, - { 6832, 6845 }, - { 6912, 6915 }, - { 6964, 6964 }, - { 6966, 6970 }, - { 6972, 6972 }, - { 6978, 6978 }, - { 7019, 7027 }, - { 7040, 7041 }, - { 7074, 7077 }, - { 7080, 7081 }, - { 7083, 7085 }, - { 7142, 7142 }, - { 7144, 7145 }, - { 7149, 7149 }, - { 7151, 7153 }, - { 7212, 7219 }, - { 7222, 7223 }, - { 7376, 7378 }, - { 7380, 7392 }, - { 7394, 7400 }, - { 7405, 7405 }, - { 7412, 7412 }, - { 7416, 7417 }, - { 7616, 7673 }, - { 7675, 7679 }, - { 8400, 8412 }, - { 8417, 8417 }, - { 8421, 8432 }, - { 11503, 11505 }, - { 11647, 11647 }, - { 11744, 11775 }, - { 12330, 12333 }, - { 12441, 12442 }, - { 42607, 42607 }, - { 42612, 42621 }, - { 42654, 42655 }, - { 42736, 42737 }, - { 43010, 43010 }, - { 43014, 43014 }, - { 43019, 43019 }, - { 43045, 43046 }, - { 43204, 43205 }, - { 43232, 43249 }, - { 43263, 43263 }, - { 43302, 43309 }, - { 43335, 43345 }, - { 43392, 43394 }, - { 43443, 43443 }, - { 43446, 43449 }, - { 43452, 43452 }, - { 43493, 43493 }, - { 43561, 43566 }, - { 43569, 43570 }, - { 43573, 43574 }, - { 43587, 43587 }, - { 43596, 43596 }, - { 43644, 43644 }, - { 43696, 43696 }, - { 43698, 43700 }, - { 43703, 43704 }, - { 43710, 43711 }, - { 43713, 43713 }, - { 43756, 43757 }, - { 43766, 43766 }, - { 44005, 44005 }, - { 44008, 44008 }, - { 44013, 44013 }, - { 64286, 64286 }, - { 65024, 65039 }, - { 65056, 65071 }, -}; -static const URange32 Mn_range32[] = { - { 66045, 66045 }, - { 66272, 66272 }, - { 66422, 66426 }, - { 68097, 68099 }, - { 68101, 68102 }, - { 68108, 68111 }, - { 68152, 68154 }, - { 68159, 68159 }, - { 68325, 68326 }, - { 68900, 68903 }, - { 69446, 69456 }, - { 69633, 69633 }, - { 69688, 69702 }, - { 69759, 69761 }, - { 69811, 69814 }, - { 69817, 69818 }, - { 69888, 69890 }, - { 69927, 69931 }, - { 69933, 69940 }, - { 70003, 70003 }, - { 70016, 70017 }, - { 70070, 70078 }, - { 70089, 70092 }, - { 70191, 70193 }, - { 70196, 70196 }, - { 70198, 70199 }, - { 70206, 70206 }, - { 70367, 70367 }, - { 70371, 70378 }, - { 70400, 70401 }, - { 70459, 70460 }, - { 70464, 70464 }, - { 70502, 70508 }, - { 70512, 70516 }, - { 70712, 70719 }, - { 70722, 70724 }, - { 70726, 70726 }, - { 70750, 70750 }, - { 70835, 70840 }, - { 70842, 70842 }, - { 70847, 70848 }, - { 70850, 70851 }, - { 71090, 71093 }, - { 71100, 71101 }, - { 71103, 71104 }, - { 71132, 71133 }, - { 71219, 71226 }, - { 71229, 71229 }, - { 71231, 71232 }, - { 71339, 71339 }, - { 71341, 71341 }, - { 71344, 71349 }, - { 71351, 71351 }, - { 71453, 71455 }, - { 71458, 71461 }, - { 71463, 71467 }, - { 71727, 71735 }, - { 71737, 71738 }, - { 72193, 72202 }, - { 72243, 72248 }, - { 72251, 72254 }, - { 72263, 72263 }, - { 72273, 72278 }, - { 72281, 72283 }, - { 72330, 72342 }, - { 72344, 72345 }, - { 72752, 72758 }, - { 72760, 72765 }, - { 72767, 72767 }, - { 72850, 72871 }, - { 72874, 72880 }, - { 72882, 72883 }, - { 72885, 72886 }, - { 73009, 73014 }, - { 73018, 73018 }, - { 73020, 73021 }, - { 73023, 73029 }, - { 73031, 73031 }, - { 73104, 73105 }, - { 73109, 73109 }, - { 73111, 73111 }, - { 73459, 73460 }, - { 92912, 92916 }, - { 92976, 92982 }, - { 94095, 94098 }, - { 113821, 113822 }, - { 119143, 119145 }, - { 119163, 119170 }, - { 119173, 119179 }, - { 119210, 119213 }, - { 119362, 119364 }, - { 121344, 121398 }, - { 121403, 121452 }, - { 121461, 121461 }, - { 121476, 121476 }, - { 121499, 121503 }, - { 121505, 121519 }, - { 122880, 122886 }, - { 122888, 122904 }, - { 122907, 122913 }, - { 122915, 122916 }, - { 122918, 122922 }, - { 125136, 125142 }, - { 125252, 125258 }, - { 917760, 917999 }, -}; -static const URange16 M_range16[] = { - { 768, 879 }, - { 1155, 1161 }, - { 1425, 1469 }, - { 1471, 1471 }, - { 1473, 1474 }, - { 1476, 1477 }, - { 1479, 1479 }, - { 1552, 1562 }, - { 1611, 1631 }, - { 1648, 1648 }, - { 1750, 1756 }, - { 1759, 1764 }, - { 1767, 1768 }, - { 1770, 1773 }, - { 1809, 1809 }, - { 1840, 1866 }, - { 1958, 1968 }, - { 2027, 2035 }, - { 2045, 2045 }, - { 2070, 2073 }, - { 2075, 2083 }, - { 2085, 2087 }, - { 2089, 2093 }, - { 2137, 2139 }, - { 2259, 2273 }, - { 2275, 2307 }, - { 2362, 2364 }, - { 2366, 2383 }, - { 2385, 2391 }, - { 2402, 2403 }, - { 2433, 2435 }, - { 2492, 2492 }, - { 2494, 2500 }, - { 2503, 2504 }, - { 2507, 2509 }, - { 2519, 2519 }, - { 2530, 2531 }, - { 2558, 2558 }, - { 2561, 2563 }, - { 2620, 2620 }, - { 2622, 2626 }, - { 2631, 2632 }, - { 2635, 2637 }, - { 2641, 2641 }, - { 2672, 2673 }, - { 2677, 2677 }, - { 2689, 2691 }, - { 2748, 2748 }, - { 2750, 2757 }, - { 2759, 2761 }, - { 2763, 2765 }, - { 2786, 2787 }, - { 2810, 2815 }, - { 2817, 2819 }, - { 2876, 2876 }, - { 2878, 2884 }, - { 2887, 2888 }, - { 2891, 2893 }, - { 2902, 2903 }, - { 2914, 2915 }, - { 2946, 2946 }, - { 3006, 3010 }, - { 3014, 3016 }, - { 3018, 3021 }, - { 3031, 3031 }, - { 3072, 3076 }, - { 3134, 3140 }, - { 3142, 3144 }, - { 3146, 3149 }, - { 3157, 3158 }, - { 3170, 3171 }, - { 3201, 3203 }, - { 3260, 3260 }, - { 3262, 3268 }, - { 3270, 3272 }, - { 3274, 3277 }, - { 3285, 3286 }, - { 3298, 3299 }, - { 3328, 3331 }, - { 3387, 3388 }, - { 3390, 3396 }, - { 3398, 3400 }, - { 3402, 3405 }, - { 3415, 3415 }, - { 3426, 3427 }, - { 3458, 3459 }, - { 3530, 3530 }, - { 3535, 3540 }, - { 3542, 3542 }, - { 3544, 3551 }, - { 3570, 3571 }, - { 3633, 3633 }, - { 3636, 3642 }, - { 3655, 3662 }, - { 3761, 3761 }, - { 3764, 3769 }, - { 3771, 3772 }, - { 3784, 3789 }, - { 3864, 3865 }, - { 3893, 3893 }, - { 3895, 3895 }, - { 3897, 3897 }, - { 3902, 3903 }, - { 3953, 3972 }, - { 3974, 3975 }, - { 3981, 3991 }, - { 3993, 4028 }, - { 4038, 4038 }, - { 4139, 4158 }, - { 4182, 4185 }, - { 4190, 4192 }, - { 4194, 4196 }, - { 4199, 4205 }, - { 4209, 4212 }, - { 4226, 4237 }, - { 4239, 4239 }, - { 4250, 4253 }, - { 4957, 4959 }, - { 5906, 5908 }, - { 5938, 5940 }, - { 5970, 5971 }, - { 6002, 6003 }, - { 6068, 6099 }, - { 6109, 6109 }, - { 6155, 6157 }, - { 6277, 6278 }, - { 6313, 6313 }, - { 6432, 6443 }, - { 6448, 6459 }, - { 6679, 6683 }, - { 6741, 6750 }, - { 6752, 6780 }, - { 6783, 6783 }, - { 6832, 6846 }, - { 6912, 6916 }, - { 6964, 6980 }, - { 7019, 7027 }, - { 7040, 7042 }, - { 7073, 7085 }, - { 7142, 7155 }, - { 7204, 7223 }, - { 7376, 7378 }, - { 7380, 7400 }, - { 7405, 7405 }, - { 7410, 7412 }, - { 7415, 7417 }, - { 7616, 7673 }, - { 7675, 7679 }, - { 8400, 8432 }, - { 11503, 11505 }, - { 11647, 11647 }, - { 11744, 11775 }, - { 12330, 12335 }, - { 12441, 12442 }, - { 42607, 42610 }, - { 42612, 42621 }, - { 42654, 42655 }, - { 42736, 42737 }, - { 43010, 43010 }, - { 43014, 43014 }, - { 43019, 43019 }, - { 43043, 43047 }, - { 43136, 43137 }, - { 43188, 43205 }, - { 43232, 43249 }, - { 43263, 43263 }, - { 43302, 43309 }, - { 43335, 43347 }, - { 43392, 43395 }, - { 43443, 43456 }, - { 43493, 43493 }, - { 43561, 43574 }, - { 43587, 43587 }, - { 43596, 43597 }, - { 43643, 43645 }, - { 43696, 43696 }, - { 43698, 43700 }, - { 43703, 43704 }, - { 43710, 43711 }, - { 43713, 43713 }, - { 43755, 43759 }, - { 43765, 43766 }, - { 44003, 44010 }, - { 44012, 44013 }, - { 64286, 64286 }, - { 65024, 65039 }, - { 65056, 65071 }, +static const URange16 Lo_range16[] = { + { 170, 170 }, + { 186, 186 }, + { 443, 443 }, + { 448, 451 }, + { 660, 660 }, + { 1488, 1514 }, + { 1519, 1522 }, + { 1568, 1599 }, + { 1601, 1610 }, + { 1646, 1647 }, + { 1649, 1747 }, + { 1749, 1749 }, + { 1774, 1775 }, + { 1786, 1788 }, + { 1791, 1791 }, + { 1808, 1808 }, + { 1810, 1839 }, + { 1869, 1957 }, + { 1969, 1969 }, + { 1994, 2026 }, + { 2048, 2069 }, + { 2112, 2136 }, + { 2144, 2154 }, + { 2208, 2228 }, + { 2230, 2237 }, + { 2308, 2361 }, + { 2365, 2365 }, + { 2384, 2384 }, + { 2392, 2401 }, + { 2418, 2432 }, + { 2437, 2444 }, + { 2447, 2448 }, + { 2451, 2472 }, + { 2474, 2480 }, + { 2482, 2482 }, + { 2486, 2489 }, + { 2493, 2493 }, + { 2510, 2510 }, + { 2524, 2525 }, + { 2527, 2529 }, + { 2544, 2545 }, + { 2556, 2556 }, + { 2565, 2570 }, + { 2575, 2576 }, + { 2579, 2600 }, + { 2602, 2608 }, + { 2610, 2611 }, + { 2613, 2614 }, + { 2616, 2617 }, + { 2649, 2652 }, + { 2654, 2654 }, + { 2674, 2676 }, + { 2693, 2701 }, + { 2703, 2705 }, + { 2707, 2728 }, + { 2730, 2736 }, + { 2738, 2739 }, + { 2741, 2745 }, + { 2749, 2749 }, + { 2768, 2768 }, + { 2784, 2785 }, + { 2809, 2809 }, + { 2821, 2828 }, + { 2831, 2832 }, + { 2835, 2856 }, + { 2858, 2864 }, + { 2866, 2867 }, + { 2869, 2873 }, + { 2877, 2877 }, + { 2908, 2909 }, + { 2911, 2913 }, + { 2929, 2929 }, + { 2947, 2947 }, + { 2949, 2954 }, + { 2958, 2960 }, + { 2962, 2965 }, + { 2969, 2970 }, + { 2972, 2972 }, + { 2974, 2975 }, + { 2979, 2980 }, + { 2984, 2986 }, + { 2990, 3001 }, + { 3024, 3024 }, + { 3077, 3084 }, + { 3086, 3088 }, + { 3090, 3112 }, + { 3114, 3129 }, + { 3133, 3133 }, + { 3160, 3162 }, + { 3168, 3169 }, + { 3200, 3200 }, + { 3205, 3212 }, + { 3214, 3216 }, + { 3218, 3240 }, + { 3242, 3251 }, + { 3253, 3257 }, + { 3261, 3261 }, + { 3294, 3294 }, + { 3296, 3297 }, + { 3313, 3314 }, + { 3333, 3340 }, + { 3342, 3344 }, + { 3346, 3386 }, + { 3389, 3389 }, + { 3406, 3406 }, + { 3412, 3414 }, + { 3423, 3425 }, + { 3450, 3455 }, + { 3461, 3478 }, + { 3482, 3505 }, + { 3507, 3515 }, + { 3517, 3517 }, + { 3520, 3526 }, + { 3585, 3632 }, + { 3634, 3635 }, + { 3648, 3653 }, + { 3713, 3714 }, + { 3716, 3716 }, + { 3718, 3722 }, + { 3724, 3747 }, + { 3749, 3749 }, + { 3751, 3760 }, + { 3762, 3763 }, + { 3773, 3773 }, + { 3776, 3780 }, + { 3804, 3807 }, + { 3840, 3840 }, + { 3904, 3911 }, + { 3913, 3948 }, + { 3976, 3980 }, + { 4096, 4138 }, + { 4159, 4159 }, + { 4176, 4181 }, + { 4186, 4189 }, + { 4193, 4193 }, + { 4197, 4198 }, + { 4206, 4208 }, + { 4213, 4225 }, + { 4238, 4238 }, + { 4352, 4680 }, + { 4682, 4685 }, + { 4688, 4694 }, + { 4696, 4696 }, + { 4698, 4701 }, + { 4704, 4744 }, + { 4746, 4749 }, + { 4752, 4784 }, + { 4786, 4789 }, + { 4792, 4798 }, + { 4800, 4800 }, + { 4802, 4805 }, + { 4808, 4822 }, + { 4824, 4880 }, + { 4882, 4885 }, + { 4888, 4954 }, + { 4992, 5007 }, + { 5121, 5740 }, + { 5743, 5759 }, + { 5761, 5786 }, + { 5792, 5866 }, + { 5873, 5880 }, + { 5888, 5900 }, + { 5902, 5905 }, + { 5920, 5937 }, + { 5952, 5969 }, + { 5984, 5996 }, + { 5998, 6000 }, + { 6016, 6067 }, + { 6108, 6108 }, + { 6176, 6210 }, + { 6212, 6264 }, + { 6272, 6276 }, + { 6279, 6312 }, + { 6314, 6314 }, + { 6320, 6389 }, + { 6400, 6430 }, + { 6480, 6509 }, + { 6512, 6516 }, + { 6528, 6571 }, + { 6576, 6601 }, + { 6656, 6678 }, + { 6688, 6740 }, + { 6917, 6963 }, + { 6981, 6987 }, + { 7043, 7072 }, + { 7086, 7087 }, + { 7098, 7141 }, + { 7168, 7203 }, + { 7245, 7247 }, + { 7258, 7287 }, + { 7401, 7404 }, + { 7406, 7411 }, + { 7413, 7414 }, + { 7418, 7418 }, + { 8501, 8504 }, + { 11568, 11623 }, + { 11648, 11670 }, + { 11680, 11686 }, + { 11688, 11694 }, + { 11696, 11702 }, + { 11704, 11710 }, + { 11712, 11718 }, + { 11720, 11726 }, + { 11728, 11734 }, + { 11736, 11742 }, + { 12294, 12294 }, + { 12348, 12348 }, + { 12353, 12438 }, + { 12447, 12447 }, + { 12449, 12538 }, + { 12543, 12543 }, + { 12549, 12591 }, + { 12593, 12686 }, + { 12704, 12730 }, + { 12784, 12799 }, + { 13312, 19893 }, + { 19968, 40943 }, + { 40960, 40980 }, + { 40982, 42124 }, + { 42192, 42231 }, + { 42240, 42507 }, + { 42512, 42527 }, + { 42538, 42539 }, + { 42606, 42606 }, + { 42656, 42725 }, + { 42895, 42895 }, + { 42999, 42999 }, + { 43003, 43009 }, + { 43011, 43013 }, + { 43015, 43018 }, + { 43020, 43042 }, + { 43072, 43123 }, + { 43138, 43187 }, + { 43250, 43255 }, + { 43259, 43259 }, + { 43261, 43262 }, + { 43274, 43301 }, + { 43312, 43334 }, + { 43360, 43388 }, + { 43396, 43442 }, + { 43488, 43492 }, + { 43495, 43503 }, + { 43514, 43518 }, + { 43520, 43560 }, + { 43584, 43586 }, + { 43588, 43595 }, + { 43616, 43631 }, + { 43633, 43638 }, + { 43642, 43642 }, + { 43646, 43695 }, + { 43697, 43697 }, + { 43701, 43702 }, + { 43705, 43709 }, + { 43712, 43712 }, + { 43714, 43714 }, + { 43739, 43740 }, + { 43744, 43754 }, + { 43762, 43762 }, + { 43777, 43782 }, + { 43785, 43790 }, + { 43793, 43798 }, + { 43808, 43814 }, + { 43816, 43822 }, + { 43968, 44002 }, + { 44032, 55203 }, + { 55216, 55238 }, + { 55243, 55291 }, + { 63744, 64109 }, + { 64112, 64217 }, + { 64285, 64285 }, + { 64287, 64296 }, + { 64298, 64310 }, + { 64312, 64316 }, + { 64318, 64318 }, + { 64320, 64321 }, + { 64323, 64324 }, + { 64326, 64433 }, + { 64467, 64829 }, + { 64848, 64911 }, + { 64914, 64967 }, + { 65008, 65019 }, + { 65136, 65140 }, + { 65142, 65276 }, + { 65382, 65391 }, + { 65393, 65437 }, + { 65440, 65470 }, + { 65474, 65479 }, + { 65482, 65487 }, + { 65490, 65495 }, + { 65498, 65500 }, +}; +static const URange32 Lo_range32[] = { + { 65536, 65547 }, + { 65549, 65574 }, + { 65576, 65594 }, + { 65596, 65597 }, + { 65599, 65613 }, + { 65616, 65629 }, + { 65664, 65786 }, + { 66176, 66204 }, + { 66208, 66256 }, + { 66304, 66335 }, + { 66349, 66368 }, + { 66370, 66377 }, + { 66384, 66421 }, + { 66432, 66461 }, + { 66464, 66499 }, + { 66504, 66511 }, + { 66640, 66717 }, + { 66816, 66855 }, + { 66864, 66915 }, + { 67072, 67382 }, + { 67392, 67413 }, + { 67424, 67431 }, + { 67584, 67589 }, + { 67592, 67592 }, + { 67594, 67637 }, + { 67639, 67640 }, + { 67644, 67644 }, + { 67647, 67669 }, + { 67680, 67702 }, + { 67712, 67742 }, + { 67808, 67826 }, + { 67828, 67829 }, + { 67840, 67861 }, + { 67872, 67897 }, + { 67968, 68023 }, + { 68030, 68031 }, + { 68096, 68096 }, + { 68112, 68115 }, + { 68117, 68119 }, + { 68121, 68149 }, + { 68192, 68220 }, + { 68224, 68252 }, + { 68288, 68295 }, + { 68297, 68324 }, + { 68352, 68405 }, + { 68416, 68437 }, + { 68448, 68466 }, + { 68480, 68497 }, + { 68608, 68680 }, + { 68864, 68899 }, + { 69376, 69404 }, + { 69415, 69415 }, + { 69424, 69445 }, + { 69600, 69622 }, + { 69635, 69687 }, + { 69763, 69807 }, + { 69840, 69864 }, + { 69891, 69926 }, + { 69956, 69956 }, + { 69968, 70002 }, + { 70006, 70006 }, + { 70019, 70066 }, + { 70081, 70084 }, + { 70106, 70106 }, + { 70108, 70108 }, + { 70144, 70161 }, + { 70163, 70187 }, + { 70272, 70278 }, + { 70280, 70280 }, + { 70282, 70285 }, + { 70287, 70301 }, + { 70303, 70312 }, + { 70320, 70366 }, + { 70405, 70412 }, + { 70415, 70416 }, + { 70419, 70440 }, + { 70442, 70448 }, + { 70450, 70451 }, + { 70453, 70457 }, + { 70461, 70461 }, + { 70480, 70480 }, + { 70493, 70497 }, + { 70656, 70708 }, + { 70727, 70730 }, + { 70751, 70751 }, + { 70784, 70831 }, + { 70852, 70853 }, + { 70855, 70855 }, + { 71040, 71086 }, + { 71128, 71131 }, + { 71168, 71215 }, + { 71236, 71236 }, + { 71296, 71338 }, + { 71352, 71352 }, + { 71424, 71450 }, + { 71680, 71723 }, + { 71935, 71935 }, + { 72096, 72103 }, + { 72106, 72144 }, + { 72161, 72161 }, + { 72163, 72163 }, + { 72192, 72192 }, + { 72203, 72242 }, + { 72250, 72250 }, + { 72272, 72272 }, + { 72284, 72329 }, + { 72349, 72349 }, + { 72384, 72440 }, + { 72704, 72712 }, + { 72714, 72750 }, + { 72768, 72768 }, + { 72818, 72847 }, + { 72960, 72966 }, + { 72968, 72969 }, + { 72971, 73008 }, + { 73030, 73030 }, + { 73056, 73061 }, + { 73063, 73064 }, + { 73066, 73097 }, + { 73112, 73112 }, + { 73440, 73458 }, + { 73728, 74649 }, + { 74880, 75075 }, + { 77824, 78894 }, + { 82944, 83526 }, + { 92160, 92728 }, + { 92736, 92766 }, + { 92880, 92909 }, + { 92928, 92975 }, + { 93027, 93047 }, + { 93053, 93071 }, + { 93952, 94026 }, + { 94032, 94032 }, + { 94208, 100343 }, + { 100352, 101106 }, + { 110592, 110878 }, + { 110928, 110930 }, + { 110948, 110951 }, + { 110960, 111355 }, + { 113664, 113770 }, + { 113776, 113788 }, + { 113792, 113800 }, + { 113808, 113817 }, + { 123136, 123180 }, + { 123214, 123214 }, + { 123584, 123627 }, + { 124928, 125124 }, + { 126464, 126467 }, + { 126469, 126495 }, + { 126497, 126498 }, + { 126500, 126500 }, + { 126503, 126503 }, + { 126505, 126514 }, + { 126516, 126519 }, + { 126521, 126521 }, + { 126523, 126523 }, + { 126530, 126530 }, + { 126535, 126535 }, + { 126537, 126537 }, + { 126539, 126539 }, + { 126541, 126543 }, + { 126545, 126546 }, + { 126548, 126548 }, + { 126551, 126551 }, + { 126553, 126553 }, + { 126555, 126555 }, + { 126557, 126557 }, + { 126559, 126559 }, + { 126561, 126562 }, + { 126564, 126564 }, + { 126567, 126570 }, + { 126572, 126578 }, + { 126580, 126583 }, + { 126585, 126588 }, + { 126590, 126590 }, + { 126592, 126601 }, + { 126603, 126619 }, + { 126625, 126627 }, + { 126629, 126633 }, + { 126635, 126651 }, + { 131072, 173782 }, + { 173824, 177972 }, + { 177984, 178205 }, + { 178208, 183969 }, + { 183984, 191456 }, + { 194560, 195101 }, }; -static const URange32 M_range32[] = { - { 66045, 66045 }, - { 66272, 66272 }, - { 66422, 66426 }, - { 68097, 68099 }, - { 68101, 68102 }, - { 68108, 68111 }, - { 68152, 68154 }, - { 68159, 68159 }, - { 68325, 68326 }, - { 68900, 68903 }, - { 69446, 69456 }, - { 69632, 69634 }, - { 69688, 69702 }, - { 69759, 69762 }, - { 69808, 69818 }, - { 69888, 69890 }, - { 69927, 69940 }, - { 69957, 69958 }, - { 70003, 70003 }, - { 70016, 70018 }, - { 70067, 70080 }, - { 70089, 70092 }, - { 70188, 70199 }, - { 70206, 70206 }, - { 70367, 70378 }, - { 70400, 70403 }, - { 70459, 70460 }, - { 70462, 70468 }, - { 70471, 70472 }, - { 70475, 70477 }, - { 70487, 70487 }, - { 70498, 70499 }, - { 70502, 70508 }, - { 70512, 70516 }, - { 70709, 70726 }, - { 70750, 70750 }, - { 70832, 70851 }, - { 71087, 71093 }, - { 71096, 71104 }, - { 71132, 71133 }, - { 71216, 71232 }, - { 71339, 71351 }, - { 71453, 71467 }, - { 71724, 71738 }, - { 72193, 72202 }, - { 72243, 72249 }, - { 72251, 72254 }, - { 72263, 72263 }, - { 72273, 72283 }, - { 72330, 72345 }, - { 72751, 72758 }, - { 72760, 72767 }, - { 72850, 72871 }, - { 72873, 72886 }, - { 73009, 73014 }, - { 73018, 73018 }, - { 73020, 73021 }, - { 73023, 73029 }, - { 73031, 73031 }, - { 73098, 73102 }, - { 73104, 73105 }, - { 73107, 73111 }, - { 73459, 73462 }, - { 92912, 92916 }, - { 92976, 92982 }, - { 94033, 94078 }, - { 94095, 94098 }, - { 113821, 113822 }, - { 119141, 119145 }, - { 119149, 119154 }, - { 119163, 119170 }, - { 119173, 119179 }, - { 119210, 119213 }, - { 119362, 119364 }, - { 121344, 121398 }, - { 121403, 121452 }, - { 121461, 121461 }, - { 121476, 121476 }, - { 121499, 121503 }, - { 121505, 121519 }, - { 122880, 122886 }, - { 122888, 122904 }, - { 122907, 122913 }, - { 122915, 122916 }, - { 122918, 122922 }, - { 125136, 125142 }, - { 125252, 125258 }, - { 917760, 917999 }, +static const URange16 Lt_range16[] = { + { 453, 453 }, + { 456, 456 }, + { 459, 459 }, + { 498, 498 }, + { 8072, 8079 }, + { 8088, 8095 }, + { 8104, 8111 }, + { 8124, 8124 }, + { 8140, 8140 }, + { 8188, 8188 }, }; -static const URange16 L_range16[] = { +static const URange16 Lu_range16[] = { { 65, 90 }, - { 97, 122 }, - { 170, 170 }, - { 181, 181 }, - { 186, 186 }, { 192, 214 }, - { 216, 246 }, - { 248, 705 }, - { 710, 721 }, - { 736, 740 }, - { 748, 748 }, - { 750, 750 }, - { 880, 884 }, - { 886, 887 }, - { 890, 893 }, + { 216, 222 }, + { 256, 256 }, + { 258, 258 }, + { 260, 260 }, + { 262, 262 }, + { 264, 264 }, + { 266, 266 }, + { 268, 268 }, + { 270, 270 }, + { 272, 272 }, + { 274, 274 }, + { 276, 276 }, + { 278, 278 }, + { 280, 280 }, + { 282, 282 }, + { 284, 284 }, + { 286, 286 }, + { 288, 288 }, + { 290, 290 }, + { 292, 292 }, + { 294, 294 }, + { 296, 296 }, + { 298, 298 }, + { 300, 300 }, + { 302, 302 }, + { 304, 304 }, + { 306, 306 }, + { 308, 308 }, + { 310, 310 }, + { 313, 313 }, + { 315, 315 }, + { 317, 317 }, + { 319, 319 }, + { 321, 321 }, + { 323, 323 }, + { 325, 325 }, + { 327, 327 }, + { 330, 330 }, + { 332, 332 }, + { 334, 334 }, + { 336, 336 }, + { 338, 338 }, + { 340, 340 }, + { 342, 342 }, + { 344, 344 }, + { 346, 346 }, + { 348, 348 }, + { 350, 350 }, + { 352, 352 }, + { 354, 354 }, + { 356, 356 }, + { 358, 358 }, + { 360, 360 }, + { 362, 362 }, + { 364, 364 }, + { 366, 366 }, + { 368, 368 }, + { 370, 370 }, + { 372, 372 }, + { 374, 374 }, + { 376, 377 }, + { 379, 379 }, + { 381, 381 }, + { 385, 386 }, + { 388, 388 }, + { 390, 391 }, + { 393, 395 }, + { 398, 401 }, + { 403, 404 }, + { 406, 408 }, + { 412, 413 }, + { 415, 416 }, + { 418, 418 }, + { 420, 420 }, + { 422, 423 }, + { 425, 425 }, + { 428, 428 }, + { 430, 431 }, + { 433, 435 }, + { 437, 437 }, + { 439, 440 }, + { 444, 444 }, + { 452, 452 }, + { 455, 455 }, + { 458, 458 }, + { 461, 461 }, + { 463, 463 }, + { 465, 465 }, + { 467, 467 }, + { 469, 469 }, + { 471, 471 }, + { 473, 473 }, + { 475, 475 }, + { 478, 478 }, + { 480, 480 }, + { 482, 482 }, + { 484, 484 }, + { 486, 486 }, + { 488, 488 }, + { 490, 490 }, + { 492, 492 }, + { 494, 494 }, + { 497, 497 }, + { 500, 500 }, + { 502, 504 }, + { 506, 506 }, + { 508, 508 }, + { 510, 510 }, + { 512, 512 }, + { 514, 514 }, + { 516, 516 }, + { 518, 518 }, + { 520, 520 }, + { 522, 522 }, + { 524, 524 }, + { 526, 526 }, + { 528, 528 }, + { 530, 530 }, + { 532, 532 }, + { 534, 534 }, + { 536, 536 }, + { 538, 538 }, + { 540, 540 }, + { 542, 542 }, + { 544, 544 }, + { 546, 546 }, + { 548, 548 }, + { 550, 550 }, + { 552, 552 }, + { 554, 554 }, + { 556, 556 }, + { 558, 558 }, + { 560, 560 }, + { 562, 562 }, + { 570, 571 }, + { 573, 574 }, + { 577, 577 }, + { 579, 582 }, + { 584, 584 }, + { 586, 586 }, + { 588, 588 }, + { 590, 590 }, + { 880, 880 }, + { 882, 882 }, + { 886, 886 }, { 895, 895 }, { 902, 902 }, { 904, 906 }, { 908, 908 }, - { 910, 929 }, - { 931, 1013 }, - { 1015, 1153 }, - { 1162, 1327 }, - { 1329, 1366 }, - { 1369, 1369 }, - { 1376, 1416 }, - { 1488, 1514 }, - { 1519, 1522 }, - { 1568, 1610 }, - { 1646, 1647 }, - { 1649, 1747 }, - { 1749, 1749 }, - { 1765, 1766 }, - { 1774, 1775 }, - { 1786, 1788 }, - { 1791, 1791 }, - { 1808, 1808 }, - { 1810, 1839 }, - { 1869, 1957 }, - { 1969, 1969 }, - { 1994, 2026 }, - { 2036, 2037 }, - { 2042, 2042 }, - { 2048, 2069 }, - { 2074, 2074 }, - { 2084, 2084 }, - { 2088, 2088 }, - { 2112, 2136 }, - { 2144, 2154 }, - { 2208, 2228 }, - { 2230, 2237 }, - { 2308, 2361 }, - { 2365, 2365 }, - { 2384, 2384 }, - { 2392, 2401 }, - { 2417, 2432 }, - { 2437, 2444 }, - { 2447, 2448 }, - { 2451, 2472 }, - { 2474, 2480 }, - { 2482, 2482 }, - { 2486, 2489 }, - { 2493, 2493 }, - { 2510, 2510 }, - { 2524, 2525 }, - { 2527, 2529 }, - { 2544, 2545 }, - { 2556, 2556 }, - { 2565, 2570 }, - { 2575, 2576 }, - { 2579, 2600 }, - { 2602, 2608 }, - { 2610, 2611 }, - { 2613, 2614 }, - { 2616, 2617 }, - { 2649, 2652 }, - { 2654, 2654 }, - { 2674, 2676 }, - { 2693, 2701 }, - { 2703, 2705 }, - { 2707, 2728 }, - { 2730, 2736 }, - { 2738, 2739 }, - { 2741, 2745 }, - { 2749, 2749 }, - { 2768, 2768 }, - { 2784, 2785 }, - { 2809, 2809 }, - { 2821, 2828 }, - { 2831, 2832 }, - { 2835, 2856 }, - { 2858, 2864 }, - { 2866, 2867 }, - { 2869, 2873 }, - { 2877, 2877 }, - { 2908, 2909 }, - { 2911, 2913 }, - { 2929, 2929 }, - { 2947, 2947 }, - { 2949, 2954 }, - { 2958, 2960 }, - { 2962, 2965 }, - { 2969, 2970 }, - { 2972, 2972 }, - { 2974, 2975 }, - { 2979, 2980 }, - { 2984, 2986 }, - { 2990, 3001 }, - { 3024, 3024 }, - { 3077, 3084 }, - { 3086, 3088 }, - { 3090, 3112 }, - { 3114, 3129 }, - { 3133, 3133 }, - { 3160, 3162 }, - { 3168, 3169 }, - { 3200, 3200 }, - { 3205, 3212 }, - { 3214, 3216 }, - { 3218, 3240 }, - { 3242, 3251 }, - { 3253, 3257 }, - { 3261, 3261 }, - { 3294, 3294 }, - { 3296, 3297 }, - { 3313, 3314 }, - { 3333, 3340 }, - { 3342, 3344 }, - { 3346, 3386 }, - { 3389, 3389 }, - { 3406, 3406 }, - { 3412, 3414 }, - { 3423, 3425 }, - { 3450, 3455 }, - { 3461, 3478 }, - { 3482, 3505 }, - { 3507, 3515 }, - { 3517, 3517 }, - { 3520, 3526 }, - { 3585, 3632 }, - { 3634, 3635 }, - { 3648, 3654 }, - { 3713, 3714 }, - { 3716, 3716 }, - { 3719, 3720 }, - { 3722, 3722 }, - { 3725, 3725 }, - { 3732, 3735 }, - { 3737, 3743 }, - { 3745, 3747 }, - { 3749, 3749 }, - { 3751, 3751 }, - { 3754, 3755 }, - { 3757, 3760 }, - { 3762, 3763 }, - { 3773, 3773 }, - { 3776, 3780 }, - { 3782, 3782 }, - { 3804, 3807 }, - { 3840, 3840 }, - { 3904, 3911 }, - { 3913, 3948 }, - { 3976, 3980 }, - { 4096, 4138 }, - { 4159, 4159 }, - { 4176, 4181 }, - { 4186, 4189 }, - { 4193, 4193 }, - { 4197, 4198 }, - { 4206, 4208 }, - { 4213, 4225 }, - { 4238, 4238 }, + { 910, 911 }, + { 913, 929 }, + { 931, 939 }, + { 975, 975 }, + { 978, 980 }, + { 984, 984 }, + { 986, 986 }, + { 988, 988 }, + { 990, 990 }, + { 992, 992 }, + { 994, 994 }, + { 996, 996 }, + { 998, 998 }, + { 1000, 1000 }, + { 1002, 1002 }, + { 1004, 1004 }, + { 1006, 1006 }, + { 1012, 1012 }, + { 1015, 1015 }, + { 1017, 1018 }, + { 1021, 1071 }, + { 1120, 1120 }, + { 1122, 1122 }, + { 1124, 1124 }, + { 1126, 1126 }, + { 1128, 1128 }, + { 1130, 1130 }, + { 1132, 1132 }, + { 1134, 1134 }, + { 1136, 1136 }, + { 1138, 1138 }, + { 1140, 1140 }, + { 1142, 1142 }, + { 1144, 1144 }, + { 1146, 1146 }, + { 1148, 1148 }, + { 1150, 1150 }, + { 1152, 1152 }, + { 1162, 1162 }, + { 1164, 1164 }, + { 1166, 1166 }, + { 1168, 1168 }, + { 1170, 1170 }, + { 1172, 1172 }, + { 1174, 1174 }, + { 1176, 1176 }, + { 1178, 1178 }, + { 1180, 1180 }, + { 1182, 1182 }, + { 1184, 1184 }, + { 1186, 1186 }, + { 1188, 1188 }, + { 1190, 1190 }, + { 1192, 1192 }, + { 1194, 1194 }, + { 1196, 1196 }, + { 1198, 1198 }, + { 1200, 1200 }, + { 1202, 1202 }, + { 1204, 1204 }, + { 1206, 1206 }, + { 1208, 1208 }, + { 1210, 1210 }, + { 1212, 1212 }, + { 1214, 1214 }, + { 1216, 1217 }, + { 1219, 1219 }, + { 1221, 1221 }, + { 1223, 1223 }, + { 1225, 1225 }, + { 1227, 1227 }, + { 1229, 1229 }, + { 1232, 1232 }, + { 1234, 1234 }, + { 1236, 1236 }, + { 1238, 1238 }, + { 1240, 1240 }, + { 1242, 1242 }, + { 1244, 1244 }, + { 1246, 1246 }, + { 1248, 1248 }, + { 1250, 1250 }, + { 1252, 1252 }, + { 1254, 1254 }, + { 1256, 1256 }, + { 1258, 1258 }, + { 1260, 1260 }, + { 1262, 1262 }, + { 1264, 1264 }, + { 1266, 1266 }, + { 1268, 1268 }, + { 1270, 1270 }, + { 1272, 1272 }, + { 1274, 1274 }, + { 1276, 1276 }, + { 1278, 1278 }, + { 1280, 1280 }, + { 1282, 1282 }, + { 1284, 1284 }, + { 1286, 1286 }, + { 1288, 1288 }, + { 1290, 1290 }, + { 1292, 1292 }, + { 1294, 1294 }, + { 1296, 1296 }, + { 1298, 1298 }, + { 1300, 1300 }, + { 1302, 1302 }, + { 1304, 1304 }, + { 1306, 1306 }, + { 1308, 1308 }, + { 1310, 1310 }, + { 1312, 1312 }, + { 1314, 1314 }, + { 1316, 1316 }, + { 1318, 1318 }, + { 1320, 1320 }, + { 1322, 1322 }, + { 1324, 1324 }, + { 1326, 1326 }, + { 1329, 1366 }, { 4256, 4293 }, { 4295, 4295 }, { 4301, 4301 }, - { 4304, 4346 }, - { 4348, 4680 }, - { 4682, 4685 }, - { 4688, 4694 }, - { 4696, 4696 }, - { 4698, 4701 }, - { 4704, 4744 }, - { 4746, 4749 }, - { 4752, 4784 }, - { 4786, 4789 }, - { 4792, 4798 }, - { 4800, 4800 }, - { 4802, 4805 }, - { 4808, 4822 }, - { 4824, 4880 }, - { 4882, 4885 }, - { 4888, 4954 }, - { 4992, 5007 }, { 5024, 5109 }, - { 5112, 5117 }, - { 5121, 5740 }, - { 5743, 5759 }, - { 5761, 5786 }, - { 5792, 5866 }, - { 5873, 5880 }, - { 5888, 5900 }, - { 5902, 5905 }, - { 5920, 5937 }, - { 5952, 5969 }, - { 5984, 5996 }, - { 5998, 6000 }, - { 6016, 6067 }, - { 6103, 6103 }, - { 6108, 6108 }, - { 6176, 6264 }, - { 6272, 6276 }, - { 6279, 6312 }, - { 6314, 6314 }, - { 6320, 6389 }, - { 6400, 6430 }, - { 6480, 6509 }, - { 6512, 6516 }, - { 6528, 6571 }, - { 6576, 6601 }, - { 6656, 6678 }, - { 6688, 6740 }, - { 6823, 6823 }, - { 6917, 6963 }, - { 6981, 6987 }, - { 7043, 7072 }, - { 7086, 7087 }, - { 7098, 7141 }, - { 7168, 7203 }, - { 7245, 7247 }, - { 7258, 7293 }, - { 7296, 7304 }, { 7312, 7354 }, { 7357, 7359 }, - { 7401, 7404 }, - { 7406, 7409 }, - { 7413, 7414 }, - { 7424, 7615 }, - { 7680, 7957 }, + { 7680, 7680 }, + { 7682, 7682 }, + { 7684, 7684 }, + { 7686, 7686 }, + { 7688, 7688 }, + { 7690, 7690 }, + { 7692, 7692 }, + { 7694, 7694 }, + { 7696, 7696 }, + { 7698, 7698 }, + { 7700, 7700 }, + { 7702, 7702 }, + { 7704, 7704 }, + { 7706, 7706 }, + { 7708, 7708 }, + { 7710, 7710 }, + { 7712, 7712 }, + { 7714, 7714 }, + { 7716, 7716 }, + { 7718, 7718 }, + { 7720, 7720 }, + { 7722, 7722 }, + { 7724, 7724 }, + { 7726, 7726 }, + { 7728, 7728 }, + { 7730, 7730 }, + { 7732, 7732 }, + { 7734, 7734 }, + { 7736, 7736 }, + { 7738, 7738 }, + { 7740, 7740 }, + { 7742, 7742 }, + { 7744, 7744 }, + { 7746, 7746 }, + { 7748, 7748 }, + { 7750, 7750 }, + { 7752, 7752 }, + { 7754, 7754 }, + { 7756, 7756 }, + { 7758, 7758 }, + { 7760, 7760 }, + { 7762, 7762 }, + { 7764, 7764 }, + { 7766, 7766 }, + { 7768, 7768 }, + { 7770, 7770 }, + { 7772, 7772 }, + { 7774, 7774 }, + { 7776, 7776 }, + { 7778, 7778 }, + { 7780, 7780 }, + { 7782, 7782 }, + { 7784, 7784 }, + { 7786, 7786 }, + { 7788, 7788 }, + { 7790, 7790 }, + { 7792, 7792 }, + { 7794, 7794 }, + { 7796, 7796 }, + { 7798, 7798 }, + { 7800, 7800 }, + { 7802, 7802 }, + { 7804, 7804 }, + { 7806, 7806 }, + { 7808, 7808 }, + { 7810, 7810 }, + { 7812, 7812 }, + { 7814, 7814 }, + { 7816, 7816 }, + { 7818, 7818 }, + { 7820, 7820 }, + { 7822, 7822 }, + { 7824, 7824 }, + { 7826, 7826 }, + { 7828, 7828 }, + { 7838, 7838 }, + { 7840, 7840 }, + { 7842, 7842 }, + { 7844, 7844 }, + { 7846, 7846 }, + { 7848, 7848 }, + { 7850, 7850 }, + { 7852, 7852 }, + { 7854, 7854 }, + { 7856, 7856 }, + { 7858, 7858 }, + { 7860, 7860 }, + { 7862, 7862 }, + { 7864, 7864 }, + { 7866, 7866 }, + { 7868, 7868 }, + { 7870, 7870 }, + { 7872, 7872 }, + { 7874, 7874 }, + { 7876, 7876 }, + { 7878, 7878 }, + { 7880, 7880 }, + { 7882, 7882 }, + { 7884, 7884 }, + { 7886, 7886 }, + { 7888, 7888 }, + { 7890, 7890 }, + { 7892, 7892 }, + { 7894, 7894 }, + { 7896, 7896 }, + { 7898, 7898 }, + { 7900, 7900 }, + { 7902, 7902 }, + { 7904, 7904 }, + { 7906, 7906 }, + { 7908, 7908 }, + { 7910, 7910 }, + { 7912, 7912 }, + { 7914, 7914 }, + { 7916, 7916 }, + { 7918, 7918 }, + { 7920, 7920 }, + { 7922, 7922 }, + { 7924, 7924 }, + { 7926, 7926 }, + { 7928, 7928 }, + { 7930, 7930 }, + { 7932, 7932 }, + { 7934, 7934 }, + { 7944, 7951 }, { 7960, 7965 }, - { 7968, 8005 }, + { 7976, 7983 }, + { 7992, 7999 }, { 8008, 8013 }, - { 8016, 8023 }, { 8025, 8025 }, { 8027, 8027 }, { 8029, 8029 }, - { 8031, 8061 }, - { 8064, 8116 }, - { 8118, 8124 }, - { 8126, 8126 }, - { 8130, 8132 }, - { 8134, 8140 }, - { 8144, 8147 }, - { 8150, 8155 }, - { 8160, 8172 }, - { 8178, 8180 }, - { 8182, 8188 }, - { 8305, 8305 }, - { 8319, 8319 }, - { 8336, 8348 }, + { 8031, 8031 }, + { 8040, 8047 }, + { 8120, 8123 }, + { 8136, 8139 }, + { 8152, 8155 }, + { 8168, 8172 }, + { 8184, 8187 }, { 8450, 8450 }, { 8455, 8455 }, - { 8458, 8467 }, + { 8459, 8461 }, + { 8464, 8466 }, { 8469, 8469 }, { 8473, 8477 }, { 8484, 8484 }, { 8486, 8486 }, { 8488, 8488 }, { 8490, 8493 }, - { 8495, 8505 }, - { 8508, 8511 }, - { 8517, 8521 }, - { 8526, 8526 }, - { 8579, 8580 }, + { 8496, 8499 }, + { 8510, 8511 }, + { 8517, 8517 }, + { 8579, 8579 }, { 11264, 11310 }, - { 11312, 11358 }, - { 11360, 11492 }, - { 11499, 11502 }, - { 11506, 11507 }, - { 11520, 11557 }, - { 11559, 11559 }, - { 11565, 11565 }, - { 11568, 11623 }, - { 11631, 11631 }, - { 11648, 11670 }, - { 11680, 11686 }, - { 11688, 11694 }, - { 11696, 11702 }, - { 11704, 11710 }, - { 11712, 11718 }, - { 11720, 11726 }, - { 11728, 11734 }, - { 11736, 11742 }, - { 11823, 11823 }, - { 12293, 12294 }, - { 12337, 12341 }, - { 12347, 12348 }, - { 12353, 12438 }, - { 12445, 12447 }, - { 12449, 12538 }, - { 12540, 12543 }, - { 12549, 12591 }, - { 12593, 12686 }, - { 12704, 12730 }, - { 12784, 12799 }, - { 13312, 19893 }, - { 19968, 40943 }, - { 40960, 42124 }, - { 42192, 42237 }, - { 42240, 42508 }, - { 42512, 42527 }, - { 42538, 42539 }, - { 42560, 42606 }, - { 42623, 42653 }, - { 42656, 42725 }, - { 42775, 42783 }, - { 42786, 42888 }, - { 42891, 42937 }, - { 42999, 43009 }, - { 43011, 43013 }, - { 43015, 43018 }, - { 43020, 43042 }, - { 43072, 43123 }, - { 43138, 43187 }, - { 43250, 43255 }, - { 43259, 43259 }, - { 43261, 43262 }, - { 43274, 43301 }, - { 43312, 43334 }, - { 43360, 43388 }, - { 43396, 43442 }, - { 43471, 43471 }, - { 43488, 43492 }, - { 43494, 43503 }, - { 43514, 43518 }, - { 43520, 43560 }, - { 43584, 43586 }, - { 43588, 43595 }, - { 43616, 43638 }, - { 43642, 43642 }, - { 43646, 43695 }, - { 43697, 43697 }, - { 43701, 43702 }, - { 43705, 43709 }, - { 43712, 43712 }, - { 43714, 43714 }, - { 43739, 43741 }, - { 43744, 43754 }, - { 43762, 43764 }, - { 43777, 43782 }, - { 43785, 43790 }, - { 43793, 43798 }, - { 43808, 43814 }, - { 43816, 43822 }, - { 43824, 43866 }, - { 43868, 43877 }, - { 43888, 44002 }, - { 44032, 55203 }, - { 55216, 55238 }, - { 55243, 55291 }, - { 63744, 64109 }, - { 64112, 64217 }, - { 64256, 64262 }, - { 64275, 64279 }, - { 64285, 64285 }, - { 64287, 64296 }, - { 64298, 64310 }, - { 64312, 64316 }, - { 64318, 64318 }, - { 64320, 64321 }, - { 64323, 64324 }, - { 64326, 64433 }, - { 64467, 64829 }, - { 64848, 64911 }, - { 64914, 64967 }, - { 65008, 65019 }, - { 65136, 65140 }, - { 65142, 65276 }, + { 11360, 11360 }, + { 11362, 11364 }, + { 11367, 11367 }, + { 11369, 11369 }, + { 11371, 11371 }, + { 11373, 11376 }, + { 11378, 11378 }, + { 11381, 11381 }, + { 11390, 11392 }, + { 11394, 11394 }, + { 11396, 11396 }, + { 11398, 11398 }, + { 11400, 11400 }, + { 11402, 11402 }, + { 11404, 11404 }, + { 11406, 11406 }, + { 11408, 11408 }, + { 11410, 11410 }, + { 11412, 11412 }, + { 11414, 11414 }, + { 11416, 11416 }, + { 11418, 11418 }, + { 11420, 11420 }, + { 11422, 11422 }, + { 11424, 11424 }, + { 11426, 11426 }, + { 11428, 11428 }, + { 11430, 11430 }, + { 11432, 11432 }, + { 11434, 11434 }, + { 11436, 11436 }, + { 11438, 11438 }, + { 11440, 11440 }, + { 11442, 11442 }, + { 11444, 11444 }, + { 11446, 11446 }, + { 11448, 11448 }, + { 11450, 11450 }, + { 11452, 11452 }, + { 11454, 11454 }, + { 11456, 11456 }, + { 11458, 11458 }, + { 11460, 11460 }, + { 11462, 11462 }, + { 11464, 11464 }, + { 11466, 11466 }, + { 11468, 11468 }, + { 11470, 11470 }, + { 11472, 11472 }, + { 11474, 11474 }, + { 11476, 11476 }, + { 11478, 11478 }, + { 11480, 11480 }, + { 11482, 11482 }, + { 11484, 11484 }, + { 11486, 11486 }, + { 11488, 11488 }, + { 11490, 11490 }, + { 11499, 11499 }, + { 11501, 11501 }, + { 11506, 11506 }, + { 42560, 42560 }, + { 42562, 42562 }, + { 42564, 42564 }, + { 42566, 42566 }, + { 42568, 42568 }, + { 42570, 42570 }, + { 42572, 42572 }, + { 42574, 42574 }, + { 42576, 42576 }, + { 42578, 42578 }, + { 42580, 42580 }, + { 42582, 42582 }, + { 42584, 42584 }, + { 42586, 42586 }, + { 42588, 42588 }, + { 42590, 42590 }, + { 42592, 42592 }, + { 42594, 42594 }, + { 42596, 42596 }, + { 42598, 42598 }, + { 42600, 42600 }, + { 42602, 42602 }, + { 42604, 42604 }, + { 42624, 42624 }, + { 42626, 42626 }, + { 42628, 42628 }, + { 42630, 42630 }, + { 42632, 42632 }, + { 42634, 42634 }, + { 42636, 42636 }, + { 42638, 42638 }, + { 42640, 42640 }, + { 42642, 42642 }, + { 42644, 42644 }, + { 42646, 42646 }, + { 42648, 42648 }, + { 42650, 42650 }, + { 42786, 42786 }, + { 42788, 42788 }, + { 42790, 42790 }, + { 42792, 42792 }, + { 42794, 42794 }, + { 42796, 42796 }, + { 42798, 42798 }, + { 42802, 42802 }, + { 42804, 42804 }, + { 42806, 42806 }, + { 42808, 42808 }, + { 42810, 42810 }, + { 42812, 42812 }, + { 42814, 42814 }, + { 42816, 42816 }, + { 42818, 42818 }, + { 42820, 42820 }, + { 42822, 42822 }, + { 42824, 42824 }, + { 42826, 42826 }, + { 42828, 42828 }, + { 42830, 42830 }, + { 42832, 42832 }, + { 42834, 42834 }, + { 42836, 42836 }, + { 42838, 42838 }, + { 42840, 42840 }, + { 42842, 42842 }, + { 42844, 42844 }, + { 42846, 42846 }, + { 42848, 42848 }, + { 42850, 42850 }, + { 42852, 42852 }, + { 42854, 42854 }, + { 42856, 42856 }, + { 42858, 42858 }, + { 42860, 42860 }, + { 42862, 42862 }, + { 42873, 42873 }, + { 42875, 42875 }, + { 42877, 42878 }, + { 42880, 42880 }, + { 42882, 42882 }, + { 42884, 42884 }, + { 42886, 42886 }, + { 42891, 42891 }, + { 42893, 42893 }, + { 42896, 42896 }, + { 42898, 42898 }, + { 42902, 42902 }, + { 42904, 42904 }, + { 42906, 42906 }, + { 42908, 42908 }, + { 42910, 42910 }, + { 42912, 42912 }, + { 42914, 42914 }, + { 42916, 42916 }, + { 42918, 42918 }, + { 42920, 42920 }, + { 42922, 42926 }, + { 42928, 42932 }, + { 42934, 42934 }, + { 42936, 42936 }, + { 42938, 42938 }, + { 42940, 42940 }, + { 42942, 42942 }, + { 42946, 42946 }, + { 42948, 42950 }, { 65313, 65338 }, - { 65345, 65370 }, - { 65382, 65470 }, - { 65474, 65479 }, - { 65482, 65487 }, - { 65490, 65495 }, - { 65498, 65500 }, }; -static const URange32 L_range32[] = { - { 65536, 65547 }, - { 65549, 65574 }, - { 65576, 65594 }, - { 65596, 65597 }, - { 65599, 65613 }, - { 65616, 65629 }, - { 65664, 65786 }, - { 66176, 66204 }, - { 66208, 66256 }, - { 66304, 66335 }, - { 66349, 66368 }, - { 66370, 66377 }, - { 66384, 66421 }, - { 66432, 66461 }, - { 66464, 66499 }, - { 66504, 66511 }, - { 66560, 66717 }, - { 66736, 66771 }, - { 66776, 66811 }, - { 66816, 66855 }, - { 66864, 66915 }, - { 67072, 67382 }, - { 67392, 67413 }, - { 67424, 67431 }, - { 67584, 67589 }, - { 67592, 67592 }, - { 67594, 67637 }, - { 67639, 67640 }, - { 67644, 67644 }, - { 67647, 67669 }, - { 67680, 67702 }, - { 67712, 67742 }, - { 67808, 67826 }, - { 67828, 67829 }, - { 67840, 67861 }, - { 67872, 67897 }, - { 67968, 68023 }, - { 68030, 68031 }, - { 68096, 68096 }, - { 68112, 68115 }, - { 68117, 68119 }, - { 68121, 68149 }, - { 68192, 68220 }, - { 68224, 68252 }, - { 68288, 68295 }, - { 68297, 68324 }, - { 68352, 68405 }, - { 68416, 68437 }, - { 68448, 68466 }, - { 68480, 68497 }, - { 68608, 68680 }, - { 68736, 68786 }, - { 68800, 68850 }, - { 68864, 68899 }, - { 69376, 69404 }, - { 69415, 69415 }, - { 69424, 69445 }, - { 69635, 69687 }, - { 69763, 69807 }, - { 69840, 69864 }, - { 69891, 69926 }, - { 69956, 69956 }, - { 69968, 70002 }, - { 70006, 70006 }, - { 70019, 70066 }, - { 70081, 70084 }, - { 70106, 70106 }, - { 70108, 70108 }, - { 70144, 70161 }, - { 70163, 70187 }, - { 70272, 70278 }, - { 70280, 70280 }, - { 70282, 70285 }, - { 70287, 70301 }, - { 70303, 70312 }, - { 70320, 70366 }, - { 70405, 70412 }, - { 70415, 70416 }, - { 70419, 70440 }, - { 70442, 70448 }, - { 70450, 70451 }, - { 70453, 70457 }, - { 70461, 70461 }, - { 70480, 70480 }, - { 70493, 70497 }, - { 70656, 70708 }, - { 70727, 70730 }, - { 70784, 70831 }, - { 70852, 70853 }, - { 70855, 70855 }, - { 71040, 71086 }, - { 71128, 71131 }, - { 71168, 71215 }, - { 71236, 71236 }, - { 71296, 71338 }, - { 71424, 71450 }, - { 71680, 71723 }, - { 71840, 71903 }, - { 71935, 71935 }, - { 72192, 72192 }, - { 72203, 72242 }, - { 72250, 72250 }, - { 72272, 72272 }, - { 72284, 72323 }, - { 72326, 72329 }, - { 72349, 72349 }, - { 72384, 72440 }, - { 72704, 72712 }, - { 72714, 72750 }, - { 72768, 72768 }, - { 72818, 72847 }, - { 72960, 72966 }, - { 72968, 72969 }, - { 72971, 73008 }, - { 73030, 73030 }, - { 73056, 73061 }, - { 73063, 73064 }, - { 73066, 73097 }, - { 73112, 73112 }, - { 73440, 73458 }, - { 73728, 74649 }, - { 74880, 75075 }, - { 77824, 78894 }, - { 82944, 83526 }, - { 92160, 92728 }, - { 92736, 92766 }, - { 92880, 92909 }, - { 92928, 92975 }, - { 92992, 92995 }, - { 93027, 93047 }, - { 93053, 93071 }, - { 93760, 93823 }, - { 93952, 94020 }, - { 94032, 94032 }, - { 94099, 94111 }, - { 94176, 94177 }, - { 94208, 100337 }, - { 100352, 101106 }, - { 110592, 110878 }, - { 110960, 111355 }, - { 113664, 113770 }, - { 113776, 113788 }, - { 113792, 113800 }, - { 113808, 113817 }, - { 119808, 119892 }, - { 119894, 119964 }, - { 119966, 119967 }, - { 119970, 119970 }, - { 119973, 119974 }, - { 119977, 119980 }, - { 119982, 119993 }, - { 119995, 119995 }, - { 119997, 120003 }, - { 120005, 120069 }, - { 120071, 120074 }, - { 120077, 120084 }, - { 120086, 120092 }, - { 120094, 120121 }, - { 120123, 120126 }, - { 120128, 120132 }, - { 120134, 120134 }, - { 120138, 120144 }, - { 120146, 120485 }, - { 120488, 120512 }, - { 120514, 120538 }, - { 120540, 120570 }, - { 120572, 120596 }, - { 120598, 120628 }, - { 120630, 120654 }, - { 120656, 120686 }, - { 120688, 120712 }, - { 120714, 120744 }, - { 120746, 120770 }, - { 120772, 120779 }, - { 124928, 125124 }, - { 125184, 125251 }, - { 126464, 126467 }, - { 126469, 126495 }, - { 126497, 126498 }, - { 126500, 126500 }, - { 126503, 126503 }, - { 126505, 126514 }, - { 126516, 126519 }, - { 126521, 126521 }, - { 126523, 126523 }, - { 126530, 126530 }, - { 126535, 126535 }, - { 126537, 126537 }, - { 126539, 126539 }, - { 126541, 126543 }, - { 126545, 126546 }, - { 126548, 126548 }, - { 126551, 126551 }, - { 126553, 126553 }, - { 126555, 126555 }, - { 126557, 126557 }, - { 126559, 126559 }, - { 126561, 126562 }, - { 126564, 126564 }, - { 126567, 126570 }, - { 126572, 126578 }, - { 126580, 126583 }, - { 126585, 126588 }, - { 126590, 126590 }, - { 126592, 126601 }, - { 126603, 126619 }, - { 126625, 126627 }, - { 126629, 126633 }, - { 126635, 126651 }, - { 131072, 173782 }, - { 173824, 177972 }, - { 177984, 178205 }, - { 178208, 183969 }, - { 183984, 191456 }, - { 194560, 195101 }, +static const URange32 Lu_range32[] = { + { 66560, 66599 }, + { 66736, 66771 }, + { 68736, 68786 }, + { 71840, 71871 }, + { 93760, 93791 }, + { 119808, 119833 }, + { 119860, 119885 }, + { 119912, 119937 }, + { 119964, 119964 }, + { 119966, 119967 }, + { 119970, 119970 }, + { 119973, 119974 }, + { 119977, 119980 }, + { 119982, 119989 }, + { 120016, 120041 }, + { 120068, 120069 }, + { 120071, 120074 }, + { 120077, 120084 }, + { 120086, 120092 }, + { 120120, 120121 }, + { 120123, 120126 }, + { 120128, 120132 }, + { 120134, 120134 }, + { 120138, 120144 }, + { 120172, 120197 }, + { 120224, 120249 }, + { 120276, 120301 }, + { 120328, 120353 }, + { 120380, 120405 }, + { 120432, 120457 }, + { 120488, 120512 }, + { 120546, 120570 }, + { 120604, 120628 }, + { 120662, 120686 }, + { 120720, 120744 }, + { 120778, 120778 }, + { 125184, 125217 }, +}; +static const URange16 M_range16[] = { + { 768, 879 }, + { 1155, 1161 }, + { 1425, 1469 }, + { 1471, 1471 }, + { 1473, 1474 }, + { 1476, 1477 }, + { 1479, 1479 }, + { 1552, 1562 }, + { 1611, 1631 }, + { 1648, 1648 }, + { 1750, 1756 }, + { 1759, 1764 }, + { 1767, 1768 }, + { 1770, 1773 }, + { 1809, 1809 }, + { 1840, 1866 }, + { 1958, 1968 }, + { 2027, 2035 }, + { 2045, 2045 }, + { 2070, 2073 }, + { 2075, 2083 }, + { 2085, 2087 }, + { 2089, 2093 }, + { 2137, 2139 }, + { 2259, 2273 }, + { 2275, 2307 }, + { 2362, 2364 }, + { 2366, 2383 }, + { 2385, 2391 }, + { 2402, 2403 }, + { 2433, 2435 }, + { 2492, 2492 }, + { 2494, 2500 }, + { 2503, 2504 }, + { 2507, 2509 }, + { 2519, 2519 }, + { 2530, 2531 }, + { 2558, 2558 }, + { 2561, 2563 }, + { 2620, 2620 }, + { 2622, 2626 }, + { 2631, 2632 }, + { 2635, 2637 }, + { 2641, 2641 }, + { 2672, 2673 }, + { 2677, 2677 }, + { 2689, 2691 }, + { 2748, 2748 }, + { 2750, 2757 }, + { 2759, 2761 }, + { 2763, 2765 }, + { 2786, 2787 }, + { 2810, 2815 }, + { 2817, 2819 }, + { 2876, 2876 }, + { 2878, 2884 }, + { 2887, 2888 }, + { 2891, 2893 }, + { 2902, 2903 }, + { 2914, 2915 }, + { 2946, 2946 }, + { 3006, 3010 }, + { 3014, 3016 }, + { 3018, 3021 }, + { 3031, 3031 }, + { 3072, 3076 }, + { 3134, 3140 }, + { 3142, 3144 }, + { 3146, 3149 }, + { 3157, 3158 }, + { 3170, 3171 }, + { 3201, 3203 }, + { 3260, 3260 }, + { 3262, 3268 }, + { 3270, 3272 }, + { 3274, 3277 }, + { 3285, 3286 }, + { 3298, 3299 }, + { 3328, 3331 }, + { 3387, 3388 }, + { 3390, 3396 }, + { 3398, 3400 }, + { 3402, 3405 }, + { 3415, 3415 }, + { 3426, 3427 }, + { 3458, 3459 }, + { 3530, 3530 }, + { 3535, 3540 }, + { 3542, 3542 }, + { 3544, 3551 }, + { 3570, 3571 }, + { 3633, 3633 }, + { 3636, 3642 }, + { 3655, 3662 }, + { 3761, 3761 }, + { 3764, 3772 }, + { 3784, 3789 }, + { 3864, 3865 }, + { 3893, 3893 }, + { 3895, 3895 }, + { 3897, 3897 }, + { 3902, 3903 }, + { 3953, 3972 }, + { 3974, 3975 }, + { 3981, 3991 }, + { 3993, 4028 }, + { 4038, 4038 }, + { 4139, 4158 }, + { 4182, 4185 }, + { 4190, 4192 }, + { 4194, 4196 }, + { 4199, 4205 }, + { 4209, 4212 }, + { 4226, 4237 }, + { 4239, 4239 }, + { 4250, 4253 }, + { 4957, 4959 }, + { 5906, 5908 }, + { 5938, 5940 }, + { 5970, 5971 }, + { 6002, 6003 }, + { 6068, 6099 }, + { 6109, 6109 }, + { 6155, 6157 }, + { 6277, 6278 }, + { 6313, 6313 }, + { 6432, 6443 }, + { 6448, 6459 }, + { 6679, 6683 }, + { 6741, 6750 }, + { 6752, 6780 }, + { 6783, 6783 }, + { 6832, 6846 }, + { 6912, 6916 }, + { 6964, 6980 }, + { 7019, 7027 }, + { 7040, 7042 }, + { 7073, 7085 }, + { 7142, 7155 }, + { 7204, 7223 }, + { 7376, 7378 }, + { 7380, 7400 }, + { 7405, 7405 }, + { 7412, 7412 }, + { 7415, 7417 }, + { 7616, 7673 }, + { 7675, 7679 }, + { 8400, 8432 }, + { 11503, 11505 }, + { 11647, 11647 }, + { 11744, 11775 }, + { 12330, 12335 }, + { 12441, 12442 }, + { 42607, 42610 }, + { 42612, 42621 }, + { 42654, 42655 }, + { 42736, 42737 }, + { 43010, 43010 }, + { 43014, 43014 }, + { 43019, 43019 }, + { 43043, 43047 }, + { 43136, 43137 }, + { 43188, 43205 }, + { 43232, 43249 }, + { 43263, 43263 }, + { 43302, 43309 }, + { 43335, 43347 }, + { 43392, 43395 }, + { 43443, 43456 }, + { 43493, 43493 }, + { 43561, 43574 }, + { 43587, 43587 }, + { 43596, 43597 }, + { 43643, 43645 }, + { 43696, 43696 }, + { 43698, 43700 }, + { 43703, 43704 }, + { 43710, 43711 }, + { 43713, 43713 }, + { 43755, 43759 }, + { 43765, 43766 }, + { 44003, 44010 }, + { 44012, 44013 }, + { 64286, 64286 }, + { 65024, 65039 }, + { 65056, 65071 }, +}; +static const URange32 M_range32[] = { + { 66045, 66045 }, + { 66272, 66272 }, + { 66422, 66426 }, + { 68097, 68099 }, + { 68101, 68102 }, + { 68108, 68111 }, + { 68152, 68154 }, + { 68159, 68159 }, + { 68325, 68326 }, + { 68900, 68903 }, + { 69446, 69456 }, + { 69632, 69634 }, + { 69688, 69702 }, + { 69759, 69762 }, + { 69808, 69818 }, + { 69888, 69890 }, + { 69927, 69940 }, + { 69957, 69958 }, + { 70003, 70003 }, + { 70016, 70018 }, + { 70067, 70080 }, + { 70089, 70092 }, + { 70188, 70199 }, + { 70206, 70206 }, + { 70367, 70378 }, + { 70400, 70403 }, + { 70459, 70460 }, + { 70462, 70468 }, + { 70471, 70472 }, + { 70475, 70477 }, + { 70487, 70487 }, + { 70498, 70499 }, + { 70502, 70508 }, + { 70512, 70516 }, + { 70709, 70726 }, + { 70750, 70750 }, + { 70832, 70851 }, + { 71087, 71093 }, + { 71096, 71104 }, + { 71132, 71133 }, + { 71216, 71232 }, + { 71339, 71351 }, + { 71453, 71467 }, + { 71724, 71738 }, + { 72145, 72151 }, + { 72154, 72160 }, + { 72164, 72164 }, + { 72193, 72202 }, + { 72243, 72249 }, + { 72251, 72254 }, + { 72263, 72263 }, + { 72273, 72283 }, + { 72330, 72345 }, + { 72751, 72758 }, + { 72760, 72767 }, + { 72850, 72871 }, + { 72873, 72886 }, + { 73009, 73014 }, + { 73018, 73018 }, + { 73020, 73021 }, + { 73023, 73029 }, + { 73031, 73031 }, + { 73098, 73102 }, + { 73104, 73105 }, + { 73107, 73111 }, + { 73459, 73462 }, + { 92912, 92916 }, + { 92976, 92982 }, + { 94031, 94031 }, + { 94033, 94087 }, + { 94095, 94098 }, + { 113821, 113822 }, + { 119141, 119145 }, + { 119149, 119154 }, + { 119163, 119170 }, + { 119173, 119179 }, + { 119210, 119213 }, + { 119362, 119364 }, + { 121344, 121398 }, + { 121403, 121452 }, + { 121461, 121461 }, + { 121476, 121476 }, + { 121499, 121503 }, + { 121505, 121519 }, + { 122880, 122886 }, + { 122888, 122904 }, + { 122907, 122913 }, + { 122915, 122916 }, + { 122918, 122922 }, + { 123184, 123190 }, + { 123628, 123631 }, + { 125136, 125142 }, + { 125252, 125258 }, + { 917760, 917999 }, +}; +static const URange16 Mc_range16[] = { + { 2307, 2307 }, + { 2363, 2363 }, + { 2366, 2368 }, + { 2377, 2380 }, + { 2382, 2383 }, + { 2434, 2435 }, + { 2494, 2496 }, + { 2503, 2504 }, + { 2507, 2508 }, + { 2519, 2519 }, + { 2563, 2563 }, + { 2622, 2624 }, + { 2691, 2691 }, + { 2750, 2752 }, + { 2761, 2761 }, + { 2763, 2764 }, + { 2818, 2819 }, + { 2878, 2878 }, + { 2880, 2880 }, + { 2887, 2888 }, + { 2891, 2892 }, + { 2903, 2903 }, + { 3006, 3007 }, + { 3009, 3010 }, + { 3014, 3016 }, + { 3018, 3020 }, + { 3031, 3031 }, + { 3073, 3075 }, + { 3137, 3140 }, + { 3202, 3203 }, + { 3262, 3262 }, + { 3264, 3268 }, + { 3271, 3272 }, + { 3274, 3275 }, + { 3285, 3286 }, + { 3330, 3331 }, + { 3390, 3392 }, + { 3398, 3400 }, + { 3402, 3404 }, + { 3415, 3415 }, + { 3458, 3459 }, + { 3535, 3537 }, + { 3544, 3551 }, + { 3570, 3571 }, + { 3902, 3903 }, + { 3967, 3967 }, + { 4139, 4140 }, + { 4145, 4145 }, + { 4152, 4152 }, + { 4155, 4156 }, + { 4182, 4183 }, + { 4194, 4196 }, + { 4199, 4205 }, + { 4227, 4228 }, + { 4231, 4236 }, + { 4239, 4239 }, + { 4250, 4252 }, + { 6070, 6070 }, + { 6078, 6085 }, + { 6087, 6088 }, + { 6435, 6438 }, + { 6441, 6443 }, + { 6448, 6449 }, + { 6451, 6456 }, + { 6681, 6682 }, + { 6741, 6741 }, + { 6743, 6743 }, + { 6753, 6753 }, + { 6755, 6756 }, + { 6765, 6770 }, + { 6916, 6916 }, + { 6965, 6965 }, + { 6971, 6971 }, + { 6973, 6977 }, + { 6979, 6980 }, + { 7042, 7042 }, + { 7073, 7073 }, + { 7078, 7079 }, + { 7082, 7082 }, + { 7143, 7143 }, + { 7146, 7148 }, + { 7150, 7150 }, + { 7154, 7155 }, + { 7204, 7211 }, + { 7220, 7221 }, + { 7393, 7393 }, + { 7415, 7415 }, + { 12334, 12335 }, + { 43043, 43044 }, + { 43047, 43047 }, + { 43136, 43137 }, + { 43188, 43203 }, + { 43346, 43347 }, + { 43395, 43395 }, + { 43444, 43445 }, + { 43450, 43451 }, + { 43454, 43456 }, + { 43567, 43568 }, + { 43571, 43572 }, + { 43597, 43597 }, + { 43643, 43643 }, + { 43645, 43645 }, + { 43755, 43755 }, + { 43758, 43759 }, + { 43765, 43765 }, + { 44003, 44004 }, + { 44006, 44007 }, + { 44009, 44010 }, + { 44012, 44012 }, +}; +static const URange32 Mc_range32[] = { + { 69632, 69632 }, + { 69634, 69634 }, + { 69762, 69762 }, + { 69808, 69810 }, + { 69815, 69816 }, + { 69932, 69932 }, + { 69957, 69958 }, + { 70018, 70018 }, + { 70067, 70069 }, + { 70079, 70080 }, + { 70188, 70190 }, + { 70194, 70195 }, + { 70197, 70197 }, + { 70368, 70370 }, + { 70402, 70403 }, + { 70462, 70463 }, + { 70465, 70468 }, + { 70471, 70472 }, + { 70475, 70477 }, + { 70487, 70487 }, + { 70498, 70499 }, + { 70709, 70711 }, + { 70720, 70721 }, + { 70725, 70725 }, + { 70832, 70834 }, + { 70841, 70841 }, + { 70843, 70846 }, + { 70849, 70849 }, + { 71087, 71089 }, + { 71096, 71099 }, + { 71102, 71102 }, + { 71216, 71218 }, + { 71227, 71228 }, + { 71230, 71230 }, + { 71340, 71340 }, + { 71342, 71343 }, + { 71350, 71350 }, + { 71456, 71457 }, + { 71462, 71462 }, + { 71724, 71726 }, + { 71736, 71736 }, + { 72145, 72147 }, + { 72156, 72159 }, + { 72164, 72164 }, + { 72249, 72249 }, + { 72279, 72280 }, + { 72343, 72343 }, + { 72751, 72751 }, + { 72766, 72766 }, + { 72873, 72873 }, + { 72881, 72881 }, + { 72884, 72884 }, + { 73098, 73102 }, + { 73107, 73108 }, + { 73110, 73110 }, + { 73461, 73462 }, + { 94033, 94087 }, + { 119141, 119142 }, + { 119149, 119154 }, +}; +static const URange16 Me_range16[] = { + { 1160, 1161 }, + { 6846, 6846 }, + { 8413, 8416 }, + { 8418, 8420 }, + { 42608, 42610 }, +}; +static const URange16 Mn_range16[] = { + { 768, 879 }, + { 1155, 1159 }, + { 1425, 1469 }, + { 1471, 1471 }, + { 1473, 1474 }, + { 1476, 1477 }, + { 1479, 1479 }, + { 1552, 1562 }, + { 1611, 1631 }, + { 1648, 1648 }, + { 1750, 1756 }, + { 1759, 1764 }, + { 1767, 1768 }, + { 1770, 1773 }, + { 1809, 1809 }, + { 1840, 1866 }, + { 1958, 1968 }, + { 2027, 2035 }, + { 2045, 2045 }, + { 2070, 2073 }, + { 2075, 2083 }, + { 2085, 2087 }, + { 2089, 2093 }, + { 2137, 2139 }, + { 2259, 2273 }, + { 2275, 2306 }, + { 2362, 2362 }, + { 2364, 2364 }, + { 2369, 2376 }, + { 2381, 2381 }, + { 2385, 2391 }, + { 2402, 2403 }, + { 2433, 2433 }, + { 2492, 2492 }, + { 2497, 2500 }, + { 2509, 2509 }, + { 2530, 2531 }, + { 2558, 2558 }, + { 2561, 2562 }, + { 2620, 2620 }, + { 2625, 2626 }, + { 2631, 2632 }, + { 2635, 2637 }, + { 2641, 2641 }, + { 2672, 2673 }, + { 2677, 2677 }, + { 2689, 2690 }, + { 2748, 2748 }, + { 2753, 2757 }, + { 2759, 2760 }, + { 2765, 2765 }, + { 2786, 2787 }, + { 2810, 2815 }, + { 2817, 2817 }, + { 2876, 2876 }, + { 2879, 2879 }, + { 2881, 2884 }, + { 2893, 2893 }, + { 2902, 2902 }, + { 2914, 2915 }, + { 2946, 2946 }, + { 3008, 3008 }, + { 3021, 3021 }, + { 3072, 3072 }, + { 3076, 3076 }, + { 3134, 3136 }, + { 3142, 3144 }, + { 3146, 3149 }, + { 3157, 3158 }, + { 3170, 3171 }, + { 3201, 3201 }, + { 3260, 3260 }, + { 3263, 3263 }, + { 3270, 3270 }, + { 3276, 3277 }, + { 3298, 3299 }, + { 3328, 3329 }, + { 3387, 3388 }, + { 3393, 3396 }, + { 3405, 3405 }, + { 3426, 3427 }, + { 3530, 3530 }, + { 3538, 3540 }, + { 3542, 3542 }, + { 3633, 3633 }, + { 3636, 3642 }, + { 3655, 3662 }, + { 3761, 3761 }, + { 3764, 3772 }, + { 3784, 3789 }, + { 3864, 3865 }, + { 3893, 3893 }, + { 3895, 3895 }, + { 3897, 3897 }, + { 3953, 3966 }, + { 3968, 3972 }, + { 3974, 3975 }, + { 3981, 3991 }, + { 3993, 4028 }, + { 4038, 4038 }, + { 4141, 4144 }, + { 4146, 4151 }, + { 4153, 4154 }, + { 4157, 4158 }, + { 4184, 4185 }, + { 4190, 4192 }, + { 4209, 4212 }, + { 4226, 4226 }, + { 4229, 4230 }, + { 4237, 4237 }, + { 4253, 4253 }, + { 4957, 4959 }, + { 5906, 5908 }, + { 5938, 5940 }, + { 5970, 5971 }, + { 6002, 6003 }, + { 6068, 6069 }, + { 6071, 6077 }, + { 6086, 6086 }, + { 6089, 6099 }, + { 6109, 6109 }, + { 6155, 6157 }, + { 6277, 6278 }, + { 6313, 6313 }, + { 6432, 6434 }, + { 6439, 6440 }, + { 6450, 6450 }, + { 6457, 6459 }, + { 6679, 6680 }, + { 6683, 6683 }, + { 6742, 6742 }, + { 6744, 6750 }, + { 6752, 6752 }, + { 6754, 6754 }, + { 6757, 6764 }, + { 6771, 6780 }, + { 6783, 6783 }, + { 6832, 6845 }, + { 6912, 6915 }, + { 6964, 6964 }, + { 6966, 6970 }, + { 6972, 6972 }, + { 6978, 6978 }, + { 7019, 7027 }, + { 7040, 7041 }, + { 7074, 7077 }, + { 7080, 7081 }, + { 7083, 7085 }, + { 7142, 7142 }, + { 7144, 7145 }, + { 7149, 7149 }, + { 7151, 7153 }, + { 7212, 7219 }, + { 7222, 7223 }, + { 7376, 7378 }, + { 7380, 7392 }, + { 7394, 7400 }, + { 7405, 7405 }, + { 7412, 7412 }, + { 7416, 7417 }, + { 7616, 7673 }, + { 7675, 7679 }, + { 8400, 8412 }, + { 8417, 8417 }, + { 8421, 8432 }, + { 11503, 11505 }, + { 11647, 11647 }, + { 11744, 11775 }, + { 12330, 12333 }, + { 12441, 12442 }, + { 42607, 42607 }, + { 42612, 42621 }, + { 42654, 42655 }, + { 42736, 42737 }, + { 43010, 43010 }, + { 43014, 43014 }, + { 43019, 43019 }, + { 43045, 43046 }, + { 43204, 43205 }, + { 43232, 43249 }, + { 43263, 43263 }, + { 43302, 43309 }, + { 43335, 43345 }, + { 43392, 43394 }, + { 43443, 43443 }, + { 43446, 43449 }, + { 43452, 43453 }, + { 43493, 43493 }, + { 43561, 43566 }, + { 43569, 43570 }, + { 43573, 43574 }, + { 43587, 43587 }, + { 43596, 43596 }, + { 43644, 43644 }, + { 43696, 43696 }, + { 43698, 43700 }, + { 43703, 43704 }, + { 43710, 43711 }, + { 43713, 43713 }, + { 43756, 43757 }, + { 43766, 43766 }, + { 44005, 44005 }, + { 44008, 44008 }, + { 44013, 44013 }, + { 64286, 64286 }, + { 65024, 65039 }, + { 65056, 65071 }, +}; +static const URange32 Mn_range32[] = { + { 66045, 66045 }, + { 66272, 66272 }, + { 66422, 66426 }, + { 68097, 68099 }, + { 68101, 68102 }, + { 68108, 68111 }, + { 68152, 68154 }, + { 68159, 68159 }, + { 68325, 68326 }, + { 68900, 68903 }, + { 69446, 69456 }, + { 69633, 69633 }, + { 69688, 69702 }, + { 69759, 69761 }, + { 69811, 69814 }, + { 69817, 69818 }, + { 69888, 69890 }, + { 69927, 69931 }, + { 69933, 69940 }, + { 70003, 70003 }, + { 70016, 70017 }, + { 70070, 70078 }, + { 70089, 70092 }, + { 70191, 70193 }, + { 70196, 70196 }, + { 70198, 70199 }, + { 70206, 70206 }, + { 70367, 70367 }, + { 70371, 70378 }, + { 70400, 70401 }, + { 70459, 70460 }, + { 70464, 70464 }, + { 70502, 70508 }, + { 70512, 70516 }, + { 70712, 70719 }, + { 70722, 70724 }, + { 70726, 70726 }, + { 70750, 70750 }, + { 70835, 70840 }, + { 70842, 70842 }, + { 70847, 70848 }, + { 70850, 70851 }, + { 71090, 71093 }, + { 71100, 71101 }, + { 71103, 71104 }, + { 71132, 71133 }, + { 71219, 71226 }, + { 71229, 71229 }, + { 71231, 71232 }, + { 71339, 71339 }, + { 71341, 71341 }, + { 71344, 71349 }, + { 71351, 71351 }, + { 71453, 71455 }, + { 71458, 71461 }, + { 71463, 71467 }, + { 71727, 71735 }, + { 71737, 71738 }, + { 72148, 72151 }, + { 72154, 72155 }, + { 72160, 72160 }, + { 72193, 72202 }, + { 72243, 72248 }, + { 72251, 72254 }, + { 72263, 72263 }, + { 72273, 72278 }, + { 72281, 72283 }, + { 72330, 72342 }, + { 72344, 72345 }, + { 72752, 72758 }, + { 72760, 72765 }, + { 72767, 72767 }, + { 72850, 72871 }, + { 72874, 72880 }, + { 72882, 72883 }, + { 72885, 72886 }, + { 73009, 73014 }, + { 73018, 73018 }, + { 73020, 73021 }, + { 73023, 73029 }, + { 73031, 73031 }, + { 73104, 73105 }, + { 73109, 73109 }, + { 73111, 73111 }, + { 73459, 73460 }, + { 92912, 92916 }, + { 92976, 92982 }, + { 94031, 94031 }, + { 94095, 94098 }, + { 113821, 113822 }, + { 119143, 119145 }, + { 119163, 119170 }, + { 119173, 119179 }, + { 119210, 119213 }, + { 119362, 119364 }, + { 121344, 121398 }, + { 121403, 121452 }, + { 121461, 121461 }, + { 121476, 121476 }, + { 121499, 121503 }, + { 121505, 121519 }, + { 122880, 122886 }, + { 122888, 122904 }, + { 122907, 122913 }, + { 122915, 122916 }, + { 122918, 122922 }, + { 123184, 123190 }, + { 123628, 123631 }, + { 125136, 125142 }, + { 125252, 125258 }, + { 917760, 917999 }, +}; +static const URange16 N_range16[] = { + { 48, 57 }, + { 178, 179 }, + { 185, 185 }, + { 188, 190 }, + { 1632, 1641 }, + { 1776, 1785 }, + { 1984, 1993 }, + { 2406, 2415 }, + { 2534, 2543 }, + { 2548, 2553 }, + { 2662, 2671 }, + { 2790, 2799 }, + { 2918, 2927 }, + { 2930, 2935 }, + { 3046, 3058 }, + { 3174, 3183 }, + { 3192, 3198 }, + { 3302, 3311 }, + { 3416, 3422 }, + { 3430, 3448 }, + { 3558, 3567 }, + { 3664, 3673 }, + { 3792, 3801 }, + { 3872, 3891 }, + { 4160, 4169 }, + { 4240, 4249 }, + { 4969, 4988 }, + { 5870, 5872 }, + { 6112, 6121 }, + { 6128, 6137 }, + { 6160, 6169 }, + { 6470, 6479 }, + { 6608, 6618 }, + { 6784, 6793 }, + { 6800, 6809 }, + { 6992, 7001 }, + { 7088, 7097 }, + { 7232, 7241 }, + { 7248, 7257 }, + { 8304, 8304 }, + { 8308, 8313 }, + { 8320, 8329 }, + { 8528, 8578 }, + { 8581, 8585 }, + { 9312, 9371 }, + { 9450, 9471 }, + { 10102, 10131 }, + { 11517, 11517 }, + { 12295, 12295 }, + { 12321, 12329 }, + { 12344, 12346 }, + { 12690, 12693 }, + { 12832, 12841 }, + { 12872, 12879 }, + { 12881, 12895 }, + { 12928, 12937 }, + { 12977, 12991 }, + { 42528, 42537 }, + { 42726, 42735 }, + { 43056, 43061 }, + { 43216, 43225 }, + { 43264, 43273 }, + { 43472, 43481 }, + { 43504, 43513 }, + { 43600, 43609 }, + { 44016, 44025 }, + { 65296, 65305 }, +}; +static const URange32 N_range32[] = { + { 65799, 65843 }, + { 65856, 65912 }, + { 65930, 65931 }, + { 66273, 66299 }, + { 66336, 66339 }, + { 66369, 66369 }, + { 66378, 66378 }, + { 66513, 66517 }, + { 66720, 66729 }, + { 67672, 67679 }, + { 67705, 67711 }, + { 67751, 67759 }, + { 67835, 67839 }, + { 67862, 67867 }, + { 68028, 68029 }, + { 68032, 68047 }, + { 68050, 68095 }, + { 68160, 68168 }, + { 68221, 68222 }, + { 68253, 68255 }, + { 68331, 68335 }, + { 68440, 68447 }, + { 68472, 68479 }, + { 68521, 68527 }, + { 68858, 68863 }, + { 68912, 68921 }, + { 69216, 69246 }, + { 69405, 69414 }, + { 69457, 69460 }, + { 69714, 69743 }, + { 69872, 69881 }, + { 69942, 69951 }, + { 70096, 70105 }, + { 70113, 70132 }, + { 70384, 70393 }, + { 70736, 70745 }, + { 70864, 70873 }, + { 71248, 71257 }, + { 71360, 71369 }, + { 71472, 71483 }, + { 71904, 71922 }, + { 72784, 72812 }, + { 73040, 73049 }, + { 73120, 73129 }, + { 73664, 73684 }, + { 74752, 74862 }, + { 92768, 92777 }, + { 93008, 93017 }, + { 93019, 93025 }, + { 93824, 93846 }, + { 119520, 119539 }, + { 119648, 119672 }, + { 120782, 120831 }, + { 123200, 123209 }, + { 123632, 123641 }, + { 125127, 125135 }, + { 125264, 125273 }, + { 126065, 126123 }, + { 126125, 126127 }, + { 126129, 126132 }, + { 126209, 126253 }, + { 126255, 126269 }, + { 127232, 127244 }, +}; +static const URange16 Nd_range16[] = { + { 48, 57 }, + { 1632, 1641 }, + { 1776, 1785 }, + { 1984, 1993 }, + { 2406, 2415 }, + { 2534, 2543 }, + { 2662, 2671 }, + { 2790, 2799 }, + { 2918, 2927 }, + { 3046, 3055 }, + { 3174, 3183 }, + { 3302, 3311 }, + { 3430, 3439 }, + { 3558, 3567 }, + { 3664, 3673 }, + { 3792, 3801 }, + { 3872, 3881 }, + { 4160, 4169 }, + { 4240, 4249 }, + { 6112, 6121 }, + { 6160, 6169 }, + { 6470, 6479 }, + { 6608, 6617 }, + { 6784, 6793 }, + { 6800, 6809 }, + { 6992, 7001 }, + { 7088, 7097 }, + { 7232, 7241 }, + { 7248, 7257 }, + { 42528, 42537 }, + { 43216, 43225 }, + { 43264, 43273 }, + { 43472, 43481 }, + { 43504, 43513 }, + { 43600, 43609 }, + { 44016, 44025 }, + { 65296, 65305 }, +}; +static const URange32 Nd_range32[] = { + { 66720, 66729 }, + { 68912, 68921 }, + { 69734, 69743 }, + { 69872, 69881 }, + { 69942, 69951 }, + { 70096, 70105 }, + { 70384, 70393 }, + { 70736, 70745 }, + { 70864, 70873 }, + { 71248, 71257 }, + { 71360, 71369 }, + { 71472, 71481 }, + { 71904, 71913 }, + { 72784, 72793 }, + { 73040, 73049 }, + { 73120, 73129 }, + { 92768, 92777 }, + { 93008, 93017 }, + { 120782, 120831 }, + { 123200, 123209 }, + { 123632, 123641 }, + { 125264, 125273 }, +}; +static const URange16 Nl_range16[] = { + { 5870, 5872 }, + { 8544, 8578 }, + { 8581, 8584 }, + { 12295, 12295 }, + { 12321, 12329 }, + { 12344, 12346 }, + { 42726, 42735 }, +}; +static const URange32 Nl_range32[] = { + { 65856, 65908 }, + { 66369, 66369 }, + { 66378, 66378 }, + { 66513, 66517 }, + { 74752, 74862 }, }; -static const URange16 N_range16[] = { - { 48, 57 }, +static const URange16 No_range16[] = { { 178, 179 }, { 185, 185 }, { 188, 190 }, - { 1632, 1641 }, - { 1776, 1785 }, - { 1984, 1993 }, - { 2406, 2415 }, - { 2534, 2543 }, { 2548, 2553 }, - { 2662, 2671 }, - { 2790, 2799 }, - { 2918, 2927 }, { 2930, 2935 }, - { 3046, 3058 }, - { 3174, 3183 }, + { 3056, 3058 }, { 3192, 3198 }, - { 3302, 3311 }, { 3416, 3422 }, - { 3430, 3448 }, - { 3558, 3567 }, - { 3664, 3673 }, - { 3792, 3801 }, - { 3872, 3891 }, - { 4160, 4169 }, - { 4240, 4249 }, + { 3440, 3448 }, + { 3882, 3891 }, { 4969, 4988 }, - { 5870, 5872 }, - { 6112, 6121 }, { 6128, 6137 }, - { 6160, 6169 }, - { 6470, 6479 }, - { 6608, 6618 }, - { 6784, 6793 }, - { 6800, 6809 }, - { 6992, 7001 }, - { 7088, 7097 }, - { 7232, 7241 }, - { 7248, 7257 }, + { 6618, 6618 }, { 8304, 8304 }, { 8308, 8313 }, { 8320, 8329 }, - { 8528, 8578 }, - { 8581, 8585 }, + { 8528, 8543 }, + { 8585, 8585 }, { 9312, 9371 }, { 9450, 9471 }, { 10102, 10131 }, { 11517, 11517 }, - { 12295, 12295 }, - { 12321, 12329 }, - { 12344, 12346 }, { 12690, 12693 }, { 12832, 12841 }, { 12872, 12879 }, { 12881, 12895 }, { 12928, 12937 }, { 12977, 12991 }, - { 42528, 42537 }, - { 42726, 42735 }, { 43056, 43061 }, - { 43216, 43225 }, - { 43264, 43273 }, - { 43472, 43481 }, - { 43504, 43513 }, - { 43600, 43609 }, - { 44016, 44025 }, - { 65296, 65305 }, }; -static const URange32 N_range32[] = { - { 65799, 65843 }, - { 65856, 65912 }, - { 65930, 65931 }, - { 66273, 66299 }, - { 66336, 66339 }, - { 66369, 66369 }, - { 66378, 66378 }, - { 66513, 66517 }, - { 66720, 66729 }, - { 67672, 67679 }, - { 67705, 67711 }, - { 67751, 67759 }, - { 67835, 67839 }, - { 67862, 67867 }, - { 68028, 68029 }, - { 68032, 68047 }, - { 68050, 68095 }, - { 68160, 68168 }, - { 68221, 68222 }, - { 68253, 68255 }, - { 68331, 68335 }, - { 68440, 68447 }, - { 68472, 68479 }, - { 68521, 68527 }, - { 68858, 68863 }, - { 68912, 68921 }, - { 69216, 69246 }, - { 69405, 69414 }, - { 69457, 69460 }, - { 69714, 69743 }, - { 69872, 69881 }, - { 69942, 69951 }, - { 70096, 70105 }, - { 70113, 70132 }, - { 70384, 70393 }, - { 70736, 70745 }, - { 70864, 70873 }, - { 71248, 71257 }, - { 71360, 71369 }, - { 71472, 71483 }, - { 71904, 71922 }, - { 72784, 72812 }, - { 73040, 73049 }, - { 73120, 73129 }, - { 74752, 74862 }, - { 92768, 92777 }, - { 93008, 93017 }, - { 93019, 93025 }, - { 93824, 93846 }, - { 119520, 119539 }, - { 119648, 119672 }, - { 120782, 120831 }, - { 125127, 125135 }, - { 125264, 125273 }, - { 126065, 126123 }, - { 126125, 126127 }, - { 126129, 126132 }, - { 127232, 127244 }, +static const URange32 No_range32[] = { + { 65799, 65843 }, + { 65909, 65912 }, + { 65930, 65931 }, + { 66273, 66299 }, + { 66336, 66339 }, + { 67672, 67679 }, + { 67705, 67711 }, + { 67751, 67759 }, + { 67835, 67839 }, + { 67862, 67867 }, + { 68028, 68029 }, + { 68032, 68047 }, + { 68050, 68095 }, + { 68160, 68168 }, + { 68221, 68222 }, + { 68253, 68255 }, + { 68331, 68335 }, + { 68440, 68447 }, + { 68472, 68479 }, + { 68521, 68527 }, + { 68858, 68863 }, + { 69216, 69246 }, + { 69405, 69414 }, + { 69457, 69460 }, + { 69714, 69733 }, + { 70113, 70132 }, + { 71482, 71483 }, + { 71914, 71922 }, + { 72794, 72812 }, + { 73664, 73684 }, + { 93019, 93025 }, + { 93824, 93846 }, + { 119520, 119539 }, + { 119648, 119672 }, + { 125127, 125135 }, + { 126065, 126123 }, + { 126125, 126127 }, + { 126129, 126132 }, + { 126209, 126253 }, + { 126255, 126269 }, + { 127232, 127244 }, +}; +static const URange16 P_range16[] = { + { 33, 35 }, + { 37, 42 }, + { 44, 47 }, + { 58, 59 }, + { 63, 64 }, + { 91, 93 }, + { 95, 95 }, + { 123, 123 }, + { 125, 125 }, + { 161, 161 }, + { 167, 167 }, + { 171, 171 }, + { 182, 183 }, + { 187, 187 }, + { 191, 191 }, + { 894, 894 }, + { 903, 903 }, + { 1370, 1375 }, + { 1417, 1418 }, + { 1470, 1470 }, + { 1472, 1472 }, + { 1475, 1475 }, + { 1478, 1478 }, + { 1523, 1524 }, + { 1545, 1546 }, + { 1548, 1549 }, + { 1563, 1563 }, + { 1566, 1567 }, + { 1642, 1645 }, + { 1748, 1748 }, + { 1792, 1805 }, + { 2039, 2041 }, + { 2096, 2110 }, + { 2142, 2142 }, + { 2404, 2405 }, + { 2416, 2416 }, + { 2557, 2557 }, + { 2678, 2678 }, + { 2800, 2800 }, + { 3191, 3191 }, + { 3204, 3204 }, + { 3572, 3572 }, + { 3663, 3663 }, + { 3674, 3675 }, + { 3844, 3858 }, + { 3860, 3860 }, + { 3898, 3901 }, + { 3973, 3973 }, + { 4048, 4052 }, + { 4057, 4058 }, + { 4170, 4175 }, + { 4347, 4347 }, + { 4960, 4968 }, + { 5120, 5120 }, + { 5742, 5742 }, + { 5787, 5788 }, + { 5867, 5869 }, + { 5941, 5942 }, + { 6100, 6102 }, + { 6104, 6106 }, + { 6144, 6154 }, + { 6468, 6469 }, + { 6686, 6687 }, + { 6816, 6822 }, + { 6824, 6829 }, + { 7002, 7008 }, + { 7164, 7167 }, + { 7227, 7231 }, + { 7294, 7295 }, + { 7360, 7367 }, + { 7379, 7379 }, + { 8208, 8231 }, + { 8240, 8259 }, + { 8261, 8273 }, + { 8275, 8286 }, + { 8317, 8318 }, + { 8333, 8334 }, + { 8968, 8971 }, + { 9001, 9002 }, + { 10088, 10101 }, + { 10181, 10182 }, + { 10214, 10223 }, + { 10627, 10648 }, + { 10712, 10715 }, + { 10748, 10749 }, + { 11513, 11516 }, + { 11518, 11519 }, + { 11632, 11632 }, + { 11776, 11822 }, + { 11824, 11855 }, + { 12289, 12291 }, + { 12296, 12305 }, + { 12308, 12319 }, + { 12336, 12336 }, + { 12349, 12349 }, + { 12448, 12448 }, + { 12539, 12539 }, + { 42238, 42239 }, + { 42509, 42511 }, + { 42611, 42611 }, + { 42622, 42622 }, + { 42738, 42743 }, + { 43124, 43127 }, + { 43214, 43215 }, + { 43256, 43258 }, + { 43260, 43260 }, + { 43310, 43311 }, + { 43359, 43359 }, + { 43457, 43469 }, + { 43486, 43487 }, + { 43612, 43615 }, + { 43742, 43743 }, + { 43760, 43761 }, + { 44011, 44011 }, + { 64830, 64831 }, + { 65040, 65049 }, + { 65072, 65106 }, + { 65108, 65121 }, + { 65123, 65123 }, + { 65128, 65128 }, + { 65130, 65131 }, + { 65281, 65283 }, + { 65285, 65290 }, + { 65292, 65295 }, + { 65306, 65307 }, + { 65311, 65312 }, + { 65339, 65341 }, + { 65343, 65343 }, + { 65371, 65371 }, + { 65373, 65373 }, + { 65375, 65381 }, +}; +static const URange32 P_range32[] = { + { 65792, 65794 }, + { 66463, 66463 }, + { 66512, 66512 }, + { 66927, 66927 }, + { 67671, 67671 }, + { 67871, 67871 }, + { 67903, 67903 }, + { 68176, 68184 }, + { 68223, 68223 }, + { 68336, 68342 }, + { 68409, 68415 }, + { 68505, 68508 }, + { 69461, 69465 }, + { 69703, 69709 }, + { 69819, 69820 }, + { 69822, 69825 }, + { 69952, 69955 }, + { 70004, 70005 }, + { 70085, 70088 }, + { 70093, 70093 }, + { 70107, 70107 }, + { 70109, 70111 }, + { 70200, 70205 }, + { 70313, 70313 }, + { 70731, 70735 }, + { 70747, 70747 }, + { 70749, 70749 }, + { 70854, 70854 }, + { 71105, 71127 }, + { 71233, 71235 }, + { 71264, 71276 }, + { 71484, 71486 }, + { 71739, 71739 }, + { 72162, 72162 }, + { 72255, 72262 }, + { 72346, 72348 }, + { 72350, 72354 }, + { 72769, 72773 }, + { 72816, 72817 }, + { 73463, 73464 }, + { 73727, 73727 }, + { 74864, 74868 }, + { 92782, 92783 }, + { 92917, 92917 }, + { 92983, 92987 }, + { 92996, 92996 }, + { 93847, 93850 }, + { 94178, 94178 }, + { 113823, 113823 }, + { 121479, 121483 }, + { 125278, 125279 }, +}; +static const URange16 Pc_range16[] = { + { 95, 95 }, + { 8255, 8256 }, + { 8276, 8276 }, + { 65075, 65076 }, + { 65101, 65103 }, + { 65343, 65343 }, }; -static const URange16 Sk_range16[] = { - { 94, 94 }, - { 96, 96 }, - { 168, 168 }, - { 175, 175 }, - { 180, 180 }, - { 184, 184 }, - { 706, 709 }, - { 722, 735 }, - { 741, 747 }, - { 749, 749 }, - { 751, 767 }, - { 885, 885 }, - { 900, 901 }, - { 8125, 8125 }, - { 8127, 8129 }, - { 8141, 8143 }, - { 8157, 8159 }, - { 8173, 8175 }, - { 8189, 8190 }, - { 12443, 12444 }, - { 42752, 42774 }, - { 42784, 42785 }, - { 42889, 42890 }, - { 43867, 43867 }, - { 64434, 64449 }, - { 65342, 65342 }, - { 65344, 65344 }, - { 65507, 65507 }, +static const URange16 Pd_range16[] = { + { 45, 45 }, + { 1418, 1418 }, + { 1470, 1470 }, + { 5120, 5120 }, + { 6150, 6150 }, + { 8208, 8213 }, + { 11799, 11799 }, + { 11802, 11802 }, + { 11834, 11835 }, + { 11840, 11840 }, + { 12316, 12316 }, + { 12336, 12336 }, + { 12448, 12448 }, + { 65073, 65074 }, + { 65112, 65112 }, + { 65123, 65123 }, + { 65293, 65293 }, }; -static const URange32 Sk_range32[] = { - { 127995, 127999 }, +static const URange16 Pe_range16[] = { + { 41, 41 }, + { 93, 93 }, + { 125, 125 }, + { 3899, 3899 }, + { 3901, 3901 }, + { 5788, 5788 }, + { 8262, 8262 }, + { 8318, 8318 }, + { 8334, 8334 }, + { 8969, 8969 }, + { 8971, 8971 }, + { 9002, 9002 }, + { 10089, 10089 }, + { 10091, 10091 }, + { 10093, 10093 }, + { 10095, 10095 }, + { 10097, 10097 }, + { 10099, 10099 }, + { 10101, 10101 }, + { 10182, 10182 }, + { 10215, 10215 }, + { 10217, 10217 }, + { 10219, 10219 }, + { 10221, 10221 }, + { 10223, 10223 }, + { 10628, 10628 }, + { 10630, 10630 }, + { 10632, 10632 }, + { 10634, 10634 }, + { 10636, 10636 }, + { 10638, 10638 }, + { 10640, 10640 }, + { 10642, 10642 }, + { 10644, 10644 }, + { 10646, 10646 }, + { 10648, 10648 }, + { 10713, 10713 }, + { 10715, 10715 }, + { 10749, 10749 }, + { 11811, 11811 }, + { 11813, 11813 }, + { 11815, 11815 }, + { 11817, 11817 }, + { 12297, 12297 }, + { 12299, 12299 }, + { 12301, 12301 }, + { 12303, 12303 }, + { 12305, 12305 }, + { 12309, 12309 }, + { 12311, 12311 }, + { 12313, 12313 }, + { 12315, 12315 }, + { 12318, 12319 }, + { 64830, 64830 }, + { 65048, 65048 }, + { 65078, 65078 }, + { 65080, 65080 }, + { 65082, 65082 }, + { 65084, 65084 }, + { 65086, 65086 }, + { 65088, 65088 }, + { 65090, 65090 }, + { 65092, 65092 }, + { 65096, 65096 }, + { 65114, 65114 }, + { 65116, 65116 }, + { 65118, 65118 }, + { 65289, 65289 }, + { 65341, 65341 }, + { 65373, 65373 }, + { 65376, 65376 }, + { 65379, 65379 }, }; -static const URange16 P_range16[] = { +static const URange16 Pf_range16[] = { + { 187, 187 }, + { 8217, 8217 }, + { 8221, 8221 }, + { 8250, 8250 }, + { 11779, 11779 }, + { 11781, 11781 }, + { 11786, 11786 }, + { 11789, 11789 }, + { 11805, 11805 }, + { 11809, 11809 }, +}; +static const URange16 Pi_range16[] = { + { 171, 171 }, + { 8216, 8216 }, + { 8219, 8220 }, + { 8223, 8223 }, + { 8249, 8249 }, + { 11778, 11778 }, + { 11780, 11780 }, + { 11785, 11785 }, + { 11788, 11788 }, + { 11804, 11804 }, + { 11808, 11808 }, +}; +static const URange16 Po_range16[] = { { 33, 35 }, - { 37, 42 }, - { 44, 47 }, + { 37, 39 }, + { 42, 42 }, + { 44, 44 }, + { 46, 47 }, { 58, 59 }, { 63, 64 }, - { 91, 93 }, - { 95, 95 }, - { 123, 123 }, - { 125, 125 }, + { 92, 92 }, { 161, 161 }, { 167, 167 }, - { 171, 171 }, { 182, 183 }, - { 187, 187 }, { 191, 191 }, { 894, 894 }, { 903, 903 }, { 1370, 1375 }, - { 1417, 1418 }, - { 1470, 1470 }, + { 1417, 1417 }, { 1472, 1472 }, { 1475, 1475 }, { 1478, 1478 }, @@ -3967,27 +3949,26 @@ static const URange16 P_range16[] = { { 2557, 2557 }, { 2678, 2678 }, { 2800, 2800 }, + { 3191, 3191 }, { 3204, 3204 }, { 3572, 3572 }, { 3663, 3663 }, { 3674, 3675 }, { 3844, 3858 }, { 3860, 3860 }, - { 3898, 3901 }, { 3973, 3973 }, { 4048, 4052 }, { 4057, 4058 }, { 4170, 4175 }, { 4347, 4347 }, { 4960, 4968 }, - { 5120, 5120 }, - { 5741, 5742 }, - { 5787, 5788 }, + { 5742, 5742 }, { 5867, 5869 }, { 5941, 5942 }, { 6100, 6102 }, { 6104, 6106 }, - { 6144, 6154 }, + { 6144, 6149 }, + { 6151, 6154 }, { 6468, 6469 }, { 6686, 6687 }, { 6816, 6822 }, @@ -3998,31 +3979,31 @@ static const URange16 P_range16[] = { { 7294, 7295 }, { 7360, 7367 }, { 7379, 7379 }, - { 8208, 8231 }, - { 8240, 8259 }, - { 8261, 8273 }, - { 8275, 8286 }, - { 8317, 8318 }, - { 8333, 8334 }, - { 8968, 8971 }, - { 9001, 9002 }, - { 10088, 10101 }, - { 10181, 10182 }, - { 10214, 10223 }, - { 10627, 10648 }, - { 10712, 10715 }, - { 10748, 10749 }, + { 8214, 8215 }, + { 8224, 8231 }, + { 8240, 8248 }, + { 8251, 8254 }, + { 8257, 8259 }, + { 8263, 8273 }, + { 8275, 8275 }, + { 8277, 8286 }, { 11513, 11516 }, { 11518, 11519 }, { 11632, 11632 }, - { 11776, 11822 }, - { 11824, 11854 }, + { 11776, 11777 }, + { 11782, 11784 }, + { 11787, 11787 }, + { 11790, 11798 }, + { 11800, 11801 }, + { 11803, 11803 }, + { 11806, 11807 }, + { 11818, 11822 }, + { 11824, 11833 }, + { 11836, 11839 }, + { 11841, 11841 }, + { 11843, 11855 }, { 12289, 12291 }, - { 12296, 12305 }, - { 12308, 12319 }, - { 12336, 12336 }, { 12349, 12349 }, - { 12448, 12448 }, { 12539, 12539 }, { 42238, 42239 }, { 42509, 42511 }, @@ -4041,25 +4022,28 @@ static const URange16 P_range16[] = { { 43742, 43743 }, { 43760, 43761 }, { 44011, 44011 }, - { 64830, 64831 }, - { 65040, 65049 }, - { 65072, 65106 }, - { 65108, 65121 }, - { 65123, 65123 }, + { 65040, 65046 }, + { 65049, 65049 }, + { 65072, 65072 }, + { 65093, 65094 }, + { 65097, 65100 }, + { 65104, 65106 }, + { 65108, 65111 }, + { 65119, 65121 }, { 65128, 65128 }, { 65130, 65131 }, { 65281, 65283 }, - { 65285, 65290 }, - { 65292, 65295 }, + { 65285, 65287 }, + { 65290, 65290 }, + { 65292, 65292 }, + { 65294, 65295 }, { 65306, 65307 }, { 65311, 65312 }, - { 65339, 65341 }, - { 65343, 65343 }, - { 65371, 65371 }, - { 65373, 65373 }, - { 65375, 65381 }, + { 65340, 65340 }, + { 65377, 65377 }, + { 65380, 65381 }, }; -static const URange32 P_range32[] = { +static const URange32 Po_range32[] = { { 65792, 65794 }, { 66463, 66463 }, { 66512, 66512 }, @@ -4093,22 +4077,102 @@ static const URange32 P_range32[] = { { 71264, 71276 }, { 71484, 71486 }, { 71739, 71739 }, + { 72162, 72162 }, { 72255, 72262 }, { 72346, 72348 }, { 72350, 72354 }, { 72769, 72773 }, { 72816, 72817 }, { 73463, 73464 }, + { 73727, 73727 }, { 74864, 74868 }, { 92782, 92783 }, { 92917, 92917 }, { 92983, 92987 }, { 92996, 92996 }, { 93847, 93850 }, + { 94178, 94178 }, { 113823, 113823 }, { 121479, 121483 }, { 125278, 125279 }, }; +static const URange16 Ps_range16[] = { + { 40, 40 }, + { 91, 91 }, + { 123, 123 }, + { 3898, 3898 }, + { 3900, 3900 }, + { 5787, 5787 }, + { 8218, 8218 }, + { 8222, 8222 }, + { 8261, 8261 }, + { 8317, 8317 }, + { 8333, 8333 }, + { 8968, 8968 }, + { 8970, 8970 }, + { 9001, 9001 }, + { 10088, 10088 }, + { 10090, 10090 }, + { 10092, 10092 }, + { 10094, 10094 }, + { 10096, 10096 }, + { 10098, 10098 }, + { 10100, 10100 }, + { 10181, 10181 }, + { 10214, 10214 }, + { 10216, 10216 }, + { 10218, 10218 }, + { 10220, 10220 }, + { 10222, 10222 }, + { 10627, 10627 }, + { 10629, 10629 }, + { 10631, 10631 }, + { 10633, 10633 }, + { 10635, 10635 }, + { 10637, 10637 }, + { 10639, 10639 }, + { 10641, 10641 }, + { 10643, 10643 }, + { 10645, 10645 }, + { 10647, 10647 }, + { 10712, 10712 }, + { 10714, 10714 }, + { 10748, 10748 }, + { 11810, 11810 }, + { 11812, 11812 }, + { 11814, 11814 }, + { 11816, 11816 }, + { 11842, 11842 }, + { 12296, 12296 }, + { 12298, 12298 }, + { 12300, 12300 }, + { 12302, 12302 }, + { 12304, 12304 }, + { 12308, 12308 }, + { 12310, 12310 }, + { 12312, 12312 }, + { 12314, 12314 }, + { 12317, 12317 }, + { 64831, 64831 }, + { 65047, 65047 }, + { 65077, 65077 }, + { 65079, 65079 }, + { 65081, 65081 }, + { 65083, 65083 }, + { 65085, 65085 }, + { 65087, 65087 }, + { 65089, 65089 }, + { 65091, 65091 }, + { 65095, 65095 }, + { 65113, 65113 }, + { 65115, 65115 }, + { 65117, 65117 }, + { 65288, 65288 }, + { 65339, 65339 }, + { 65371, 65371 }, + { 65375, 65375 }, + { 65378, 65378 }, +}; static const URange16 S_range16[] = { { 36, 36 }, { 43, 43 }, @@ -4165,6 +4229,7 @@ static const URange16 S_range16[] = { { 4053, 4056 }, { 4254, 4255 }, { 5008, 5017 }, + { 5741, 5741 }, { 6107, 6107 }, { 6464, 6464 }, { 6622, 6655 }, @@ -4209,8 +4274,7 @@ static const URange16 S_range16[] = { { 10716, 10747 }, { 10750, 11123 }, { 11126, 11157 }, - { 11160, 11208 }, - { 11210, 11262 }, + { 11160, 11263 }, { 11493, 11498 }, { 11904, 11929 }, { 11931, 12019 }, @@ -4230,8 +4294,7 @@ static const URange16 S_range16[] = { { 12880, 12880 }, { 12896, 12927 }, { 12938, 12976 }, - { 12992, 13054 }, - { 13056, 13311 }, + { 12992, 13311 }, { 19904, 19967 }, { 42128, 42182 }, { 42752, 42774 }, @@ -4268,6 +4331,7 @@ static const URange32 S_range32[] = { { 67703, 67704 }, { 68296, 68296 }, { 71487, 71487 }, + { 73685, 73713 }, { 92988, 92991 }, { 92997, 92997 }, { 113820, 113820 }, @@ -4296,8 +4360,11 @@ static const URange32 S_range32[] = { { 121453, 121460 }, { 121462, 121475 }, { 121477, 121478 }, + { 123215, 123215 }, + { 123647, 123647 }, { 126124, 126124 }, { 126128, 126128 }, + { 126254, 126254 }, { 126704, 126705 }, { 126976, 127019 }, { 127024, 127123 }, @@ -4305,33 +4372,162 @@ static const URange32 S_range32[] = { { 127153, 127167 }, { 127169, 127183 }, { 127185, 127221 }, - { 127248, 127339 }, + { 127248, 127340 }, { 127344, 127404 }, { 127462, 127490 }, { 127504, 127547 }, { 127552, 127560 }, { 127568, 127569 }, { 127584, 127589 }, - { 127744, 128724 }, + { 127744, 128725 }, { 128736, 128748 }, - { 128752, 128761 }, + { 128752, 128762 }, { 128768, 128883 }, { 128896, 128984 }, + { 128992, 129003 }, { 129024, 129035 }, { 129040, 129095 }, { 129104, 129113 }, { 129120, 129159 }, { 129168, 129197 }, { 129280, 129291 }, - { 129296, 129342 }, - { 129344, 129392 }, + { 129293, 129393 }, { 129395, 129398 }, - { 129402, 129402 }, - { 129404, 129442 }, - { 129456, 129465 }, - { 129472, 129474 }, - { 129488, 129535 }, + { 129402, 129442 }, + { 129445, 129450 }, + { 129454, 129482 }, + { 129485, 129619 }, { 129632, 129645 }, + { 129648, 129651 }, + { 129656, 129658 }, + { 129664, 129666 }, + { 129680, 129685 }, +}; +static const URange16 Sc_range16[] = { + { 36, 36 }, + { 162, 165 }, + { 1423, 1423 }, + { 1547, 1547 }, + { 2046, 2047 }, + { 2546, 2547 }, + { 2555, 2555 }, + { 2801, 2801 }, + { 3065, 3065 }, + { 3647, 3647 }, + { 6107, 6107 }, + { 8352, 8383 }, + { 43064, 43064 }, + { 65020, 65020 }, + { 65129, 65129 }, + { 65284, 65284 }, + { 65504, 65505 }, + { 65509, 65510 }, +}; +static const URange32 Sc_range32[] = { + { 73693, 73696 }, + { 123647, 123647 }, + { 126128, 126128 }, +}; +static const URange16 Sk_range16[] = { + { 94, 94 }, + { 96, 96 }, + { 168, 168 }, + { 175, 175 }, + { 180, 180 }, + { 184, 184 }, + { 706, 709 }, + { 722, 735 }, + { 741, 747 }, + { 749, 749 }, + { 751, 767 }, + { 885, 885 }, + { 900, 901 }, + { 8125, 8125 }, + { 8127, 8129 }, + { 8141, 8143 }, + { 8157, 8159 }, + { 8173, 8175 }, + { 8189, 8190 }, + { 12443, 12444 }, + { 42752, 42774 }, + { 42784, 42785 }, + { 42889, 42890 }, + { 43867, 43867 }, + { 64434, 64449 }, + { 65342, 65342 }, + { 65344, 65344 }, + { 65507, 65507 }, +}; +static const URange32 Sk_range32[] = { + { 127995, 127999 }, +}; +static const URange16 Sm_range16[] = { + { 43, 43 }, + { 60, 62 }, + { 124, 124 }, + { 126, 126 }, + { 172, 172 }, + { 177, 177 }, + { 215, 215 }, + { 247, 247 }, + { 1014, 1014 }, + { 1542, 1544 }, + { 8260, 8260 }, + { 8274, 8274 }, + { 8314, 8316 }, + { 8330, 8332 }, + { 8472, 8472 }, + { 8512, 8516 }, + { 8523, 8523 }, + { 8592, 8596 }, + { 8602, 8603 }, + { 8608, 8608 }, + { 8611, 8611 }, + { 8614, 8614 }, + { 8622, 8622 }, + { 8654, 8655 }, + { 8658, 8658 }, + { 8660, 8660 }, + { 8692, 8959 }, + { 8992, 8993 }, + { 9084, 9084 }, + { 9115, 9139 }, + { 9180, 9185 }, + { 9655, 9655 }, + { 9665, 9665 }, + { 9720, 9727 }, + { 9839, 9839 }, + { 10176, 10180 }, + { 10183, 10213 }, + { 10224, 10239 }, + { 10496, 10626 }, + { 10649, 10711 }, + { 10716, 10747 }, + { 10750, 11007 }, + { 11056, 11076 }, + { 11079, 11084 }, + { 64297, 64297 }, + { 65122, 65122 }, + { 65124, 65126 }, + { 65291, 65291 }, + { 65308, 65310 }, + { 65372, 65372 }, + { 65374, 65374 }, + { 65506, 65506 }, + { 65513, 65516 }, +}; +static const URange32 Sm_range32[] = { + { 120513, 120513 }, + { 120539, 120539 }, + { 120571, 120571 }, + { 120597, 120597 }, + { 120629, 120629 }, + { 120655, 120655 }, + { 120687, 120687 }, + { 120713, 120713 }, + { 120745, 120745 }, + { 120771, 120771 }, + { 126704, 126705 }, }; static const URange16 So_range16[] = { { 166, 166 }, @@ -4365,6 +4561,7 @@ static const URange16 So_range16[] = { { 4053, 4056 }, { 4254, 4255 }, { 5008, 5017 }, + { 5741, 5741 }, { 6464, 6464 }, { 6622, 6655 }, { 7009, 7018 }, @@ -4413,8 +4610,7 @@ static const URange16 So_range16[] = { { 11077, 11078 }, { 11085, 11123 }, { 11126, 11157 }, - { 11160, 11208 }, - { 11210, 11262 }, + { 11160, 11263 }, { 11493, 11498 }, { 11904, 11929 }, { 11931, 12019 }, @@ -4433,8 +4629,7 @@ static const URange16 So_range16[] = { { 12880, 12880 }, { 12896, 12927 }, { 12938, 12976 }, - { 12992, 13054 }, - { 13056, 13311 }, + { 12992, 13311 }, { 19904, 19967 }, { 42128, 42182 }, { 43048, 43051 }, @@ -4457,6 +4652,8 @@ static const URange32 So_range32[] = { { 67703, 67704 }, { 68296, 68296 }, { 71487, 71487 }, + { 73685, 73692 }, + { 73697, 73713 }, { 92988, 92991 }, { 92997, 92997 }, { 113820, 113820 }, @@ -4475,14 +4672,16 @@ static const URange32 So_range32[] = { { 121453, 121460 }, { 121462, 121475 }, { 121477, 121478 }, + { 123215, 123215 }, { 126124, 126124 }, + { 126254, 126254 }, { 126976, 127019 }, { 127024, 127123 }, { 127136, 127150 }, { 127153, 127167 }, { 127169, 127183 }, { 127185, 127221 }, - { 127248, 127339 }, + { 127248, 127340 }, { 127344, 127404 }, { 127462, 127490 }, { 127504, 127547 }, @@ -4490,344 +4689,128 @@ static const URange32 So_range32[] = { { 127568, 127569 }, { 127584, 127589 }, { 127744, 127994 }, - { 128000, 128724 }, + { 128000, 128725 }, { 128736, 128748 }, - { 128752, 128761 }, + { 128752, 128762 }, { 128768, 128883 }, { 128896, 128984 }, + { 128992, 129003 }, { 129024, 129035 }, { 129040, 129095 }, { 129104, 129113 }, { 129120, 129159 }, { 129168, 129197 }, { 129280, 129291 }, - { 129296, 129342 }, - { 129344, 129392 }, + { 129293, 129393 }, { 129395, 129398 }, - { 129402, 129402 }, - { 129404, 129442 }, - { 129456, 129465 }, - { 129472, 129474 }, - { 129488, 129535 }, + { 129402, 129442 }, + { 129445, 129450 }, + { 129454, 129482 }, + { 129485, 129619 }, { 129632, 129645 }, + { 129648, 129651 }, + { 129656, 129658 }, + { 129664, 129666 }, + { 129680, 129685 }, }; -static const URange16 Sm_range16[] = { - { 43, 43 }, - { 60, 62 }, - { 124, 124 }, - { 126, 126 }, - { 172, 172 }, - { 177, 177 }, - { 215, 215 }, - { 247, 247 }, - { 1014, 1014 }, - { 1542, 1544 }, - { 8260, 8260 }, - { 8274, 8274 }, - { 8314, 8316 }, - { 8330, 8332 }, - { 8472, 8472 }, - { 8512, 8516 }, - { 8523, 8523 }, - { 8592, 8596 }, - { 8602, 8603 }, - { 8608, 8608 }, - { 8611, 8611 }, - { 8614, 8614 }, - { 8622, 8622 }, - { 8654, 8655 }, - { 8658, 8658 }, - { 8660, 8660 }, - { 8692, 8959 }, - { 8992, 8993 }, - { 9084, 9084 }, - { 9115, 9139 }, - { 9180, 9185 }, - { 9655, 9655 }, - { 9665, 9665 }, - { 9720, 9727 }, - { 9839, 9839 }, - { 10176, 10180 }, - { 10183, 10213 }, - { 10224, 10239 }, - { 10496, 10626 }, - { 10649, 10711 }, - { 10716, 10747 }, - { 10750, 11007 }, - { 11056, 11076 }, - { 11079, 11084 }, - { 64297, 64297 }, - { 65122, 65122 }, - { 65124, 65126 }, - { 65291, 65291 }, - { 65308, 65310 }, - { 65372, 65372 }, - { 65374, 65374 }, - { 65506, 65506 }, - { 65513, 65516 }, -}; -static const URange32 Sm_range32[] = { - { 120513, 120513 }, - { 120539, 120539 }, - { 120571, 120571 }, - { 120597, 120597 }, - { 120629, 120629 }, - { 120655, 120655 }, - { 120687, 120687 }, - { 120713, 120713 }, - { 120745, 120745 }, - { 120771, 120771 }, - { 126704, 126705 }, -}; -static const URange16 Sc_range16[] = { - { 36, 36 }, - { 162, 165 }, - { 1423, 1423 }, - { 1547, 1547 }, - { 2046, 2047 }, - { 2546, 2547 }, - { 2555, 2555 }, - { 2801, 2801 }, - { 3065, 3065 }, - { 3647, 3647 }, - { 6107, 6107 }, - { 8352, 8383 }, - { 43064, 43064 }, - { 65020, 65020 }, - { 65129, 65129 }, - { 65284, 65284 }, - { 65504, 65505 }, - { 65509, 65510 }, -}; -static const URange32 Sc_range32[] = { - { 126128, 126128 }, -}; -static const URange16 Z_range16[] = { - { 32, 32 }, - { 160, 160 }, - { 5760, 5760 }, - { 8192, 8202 }, - { 8232, 8233 }, - { 8239, 8239 }, - { 8287, 8287 }, - { 12288, 12288 }, -}; -static const URange16 Zl_range16[] = { - { 8232, 8232 }, -}; -static const URange16 Co_range16[] = { - { 57344, 63743 }, -}; -static const URange32 Co_range32[] = { - { 983040, 1048573 }, - { 1048576, 1114109 }, -}; -static const URange16 Cc_range16[] = { - { 0, 31 }, - { 127, 159 }, -}; -static const URange16 Cf_range16[] = { - { 173, 173 }, - { 1536, 1541 }, - { 1564, 1564 }, - { 1757, 1757 }, - { 1807, 1807 }, - { 2274, 2274 }, - { 6158, 6158 }, - { 8203, 8207 }, - { 8234, 8238 }, - { 8288, 8292 }, - { 8294, 8303 }, - { 65279, 65279 }, - { 65529, 65531 }, -}; -static const URange32 Cf_range32[] = { - { 69821, 69821 }, - { 69837, 69837 }, - { 113824, 113827 }, - { 119155, 119162 }, - { 917505, 917505 }, - { 917536, 917631 }, -}; -static const URange16 Cs_range16[] = { - { 55296, 57343 }, -}; -static const URange16 Zp_range16[] = { - { 8233, 8233 }, -}; -static const URange16 Zs_range16[] = { - { 32, 32 }, - { 160, 160 }, - { 5760, 5760 }, - { 8192, 8202 }, - { 8239, 8239 }, - { 8287, 8287 }, - { 12288, 12288 }, -}; -static const URange32 Tangut_range32[] = { - { 94176, 94176 }, - { 94208, 100337 }, - { 100352, 101106 }, -}; -static const URange16 Thaana_range16[] = { - { 1920, 1969 }, -}; -static const URange32 Adlam_range32[] = { - { 125184, 125258 }, - { 125264, 125273 }, - { 125278, 125279 }, -}; -static const URange16 Telugu_range16[] = { - { 3072, 3084 }, - { 3086, 3088 }, - { 3090, 3112 }, - { 3114, 3129 }, - { 3133, 3140 }, - { 3142, 3144 }, - { 3146, 3149 }, - { 3157, 3158 }, - { 3160, 3162 }, - { 3168, 3171 }, - { 3174, 3183 }, - { 3192, 3199 }, -}; -static const URange16 Cyrillic_range16[] = { - { 1024, 1156 }, - { 1159, 1327 }, - { 7296, 7304 }, - { 7467, 7467 }, - { 7544, 7544 }, - { 11744, 11775 }, - { 42560, 42655 }, - { 65070, 65071 }, -}; -static const URange32 Zanabazar_Square_range32[] = { - { 72192, 72263 }, -}; -static const URange16 Hangul_range16[] = { - { 4352, 4607 }, - { 12334, 12335 }, - { 12593, 12686 }, - { 12800, 12830 }, - { 12896, 12926 }, - { 43360, 43388 }, - { 44032, 55203 }, - { 55216, 55238 }, - { 55243, 55291 }, - { 65440, 65470 }, - { 65474, 65479 }, - { 65482, 65487 }, - { 65490, 65495 }, - { 65498, 65500 }, -}; -static const URange32 Old_South_Arabian_range32[] = { - { 68192, 68223 }, -}; -static const URange16 Ethiopic_range16[] = { - { 4608, 4680 }, - { 4682, 4685 }, - { 4688, 4694 }, - { 4696, 4696 }, - { 4698, 4701 }, - { 4704, 4744 }, - { 4746, 4749 }, - { 4752, 4784 }, - { 4786, 4789 }, - { 4792, 4798 }, - { 4800, 4800 }, - { 4802, 4805 }, - { 4808, 4822 }, - { 4824, 4880 }, - { 4882, 4885 }, - { 4888, 4954 }, - { 4957, 4988 }, - { 4992, 5017 }, - { 11648, 11670 }, - { 11680, 11686 }, - { 11688, 11694 }, - { 11696, 11702 }, - { 11704, 11710 }, - { 11712, 11718 }, - { 11720, 11726 }, - { 11728, 11734 }, - { 11736, 11742 }, - { 43777, 43782 }, - { 43785, 43790 }, - { 43793, 43798 }, - { 43808, 43814 }, - { 43816, 43822 }, -}; -static const URange16 Inherited_range16[] = { - { 768, 879 }, - { 1157, 1158 }, - { 1611, 1621 }, - { 1648, 1648 }, - { 2385, 2386 }, - { 6832, 6846 }, - { 7376, 7378 }, - { 7380, 7392 }, - { 7394, 7400 }, - { 7405, 7405 }, - { 7412, 7412 }, - { 7416, 7417 }, - { 7616, 7673 }, - { 7675, 7679 }, - { 8204, 8205 }, - { 8400, 8432 }, - { 12330, 12333 }, - { 12441, 12442 }, - { 65024, 65039 }, - { 65056, 65069 }, +static const URange16 Z_range16[] = { + { 32, 32 }, + { 160, 160 }, + { 5760, 5760 }, + { 8192, 8202 }, + { 8232, 8233 }, + { 8239, 8239 }, + { 8287, 8287 }, + { 12288, 12288 }, }; -static const URange32 Inherited_range32[] = { - { 66045, 66045 }, - { 66272, 66272 }, - { 70459, 70459 }, - { 119143, 119145 }, - { 119163, 119170 }, - { 119173, 119179 }, - { 119210, 119213 }, - { 917760, 917999 }, +static const URange16 Zl_range16[] = { + { 8232, 8232 }, }; -static const URange32 Meroitic_Cursive_range32[] = { - { 68000, 68023 }, - { 68028, 68047 }, - { 68050, 68095 }, +static const URange16 Zp_range16[] = { + { 8233, 8233 }, }; -static const URange32 Bhaiksuki_range32[] = { - { 72704, 72712 }, - { 72714, 72758 }, - { 72760, 72773 }, - { 72784, 72812 }, +static const URange16 Zs_range16[] = { + { 32, 32 }, + { 160, 160 }, + { 5760, 5760 }, + { 8192, 8202 }, + { 8239, 8239 }, + { 8287, 8287 }, + { 12288, 12288 }, +}; +static const URange32 Adlam_range32[] = { + { 125184, 125259 }, + { 125264, 125273 }, + { 125278, 125279 }, }; static const URange32 Ahom_range32[] = { { 71424, 71450 }, { 71453, 71467 }, { 71472, 71487 }, }; -static const URange16 Han_range16[] = { - { 11904, 11929 }, - { 11931, 12019 }, - { 12032, 12245 }, - { 12293, 12293 }, - { 12295, 12295 }, - { 12321, 12329 }, - { 12344, 12347 }, - { 13312, 19893 }, - { 19968, 40943 }, - { 63744, 64109 }, - { 64112, 64217 }, +static const URange32 Anatolian_Hieroglyphs_range32[] = { + { 82944, 83526 }, }; -static const URange32 Han_range32[] = { - { 131072, 173782 }, - { 173824, 177972 }, - { 177984, 178205 }, - { 178208, 183969 }, - { 183984, 191456 }, - { 194560, 195101 }, +static const URange16 Arabic_range16[] = { + { 1536, 1540 }, + { 1542, 1547 }, + { 1549, 1562 }, + { 1564, 1564 }, + { 1566, 1566 }, + { 1568, 1599 }, + { 1601, 1610 }, + { 1622, 1647 }, + { 1649, 1756 }, + { 1758, 1791 }, + { 1872, 1919 }, + { 2208, 2228 }, + { 2230, 2237 }, + { 2259, 2273 }, + { 2275, 2303 }, + { 64336, 64449 }, + { 64467, 64829 }, + { 64848, 64911 }, + { 64914, 64967 }, + { 65008, 65021 }, + { 65136, 65140 }, + { 65142, 65276 }, }; -static const URange32 Old_North_Arabian_range32[] = { - { 68224, 68255 }, +static const URange32 Arabic_range32[] = { + { 69216, 69246 }, + { 126464, 126467 }, + { 126469, 126495 }, + { 126497, 126498 }, + { 126500, 126500 }, + { 126503, 126503 }, + { 126505, 126514 }, + { 126516, 126519 }, + { 126521, 126521 }, + { 126523, 126523 }, + { 126530, 126530 }, + { 126535, 126535 }, + { 126537, 126537 }, + { 126539, 126539 }, + { 126541, 126543 }, + { 126545, 126546 }, + { 126548, 126548 }, + { 126551, 126551 }, + { 126553, 126553 }, + { 126555, 126555 }, + { 126557, 126557 }, + { 126559, 126559 }, + { 126561, 126562 }, + { 126564, 126564 }, + { 126567, 126570 }, + { 126572, 126578 }, + { 126580, 126583 }, + { 126585, 126588 }, + { 126590, 126590 }, + { 126592, 126601 }, + { 126603, 126619 }, + { 126625, 126627 }, + { 126629, 126633 }, + { 126635, 126651 }, + { 126704, 126705 }, }; static const URange16 Armenian_range16[] = { { 1329, 1366 }, @@ -4836,174 +4819,363 @@ static const URange16 Armenian_range16[] = { { 1421, 1423 }, { 64275, 64279 }, }; -static const URange16 Tamil_range16[] = { - { 2946, 2947 }, - { 2949, 2954 }, - { 2958, 2960 }, - { 2962, 2965 }, - { 2969, 2970 }, - { 2972, 2972 }, - { 2974, 2975 }, - { 2979, 2980 }, - { 2984, 2986 }, - { 2990, 3001 }, - { 3006, 3010 }, - { 3014, 3016 }, - { 3018, 3021 }, - { 3024, 3024 }, - { 3031, 3031 }, - { 3046, 3066 }, +static const URange32 Avestan_range32[] = { + { 68352, 68405 }, + { 68409, 68415 }, }; -static const URange16 Bopomofo_range16[] = { - { 746, 747 }, - { 12549, 12591 }, - { 12704, 12730 }, +static const URange16 Balinese_range16[] = { + { 6912, 6987 }, + { 6992, 7036 }, +}; +static const URange16 Bamum_range16[] = { + { 42656, 42743 }, +}; +static const URange32 Bamum_range32[] = { + { 92160, 92728 }, }; static const URange32 Bassa_Vah_range32[] = { { 92880, 92909 }, { 92912, 92917 }, }; -static const URange16 Sundanese_range16[] = { - { 7040, 7103 }, - { 7360, 7367 }, +static const URange16 Batak_range16[] = { + { 7104, 7155 }, + { 7164, 7167 }, }; -static const URange32 Osage_range32[] = { - { 66736, 66771 }, - { 66776, 66811 }, +static const URange16 Bengali_range16[] = { + { 2432, 2435 }, + { 2437, 2444 }, + { 2447, 2448 }, + { 2451, 2472 }, + { 2474, 2480 }, + { 2482, 2482 }, + { 2486, 2489 }, + { 2492, 2500 }, + { 2503, 2504 }, + { 2507, 2510 }, + { 2519, 2519 }, + { 2524, 2525 }, + { 2527, 2531 }, + { 2534, 2558 }, }; -static const URange32 Old_Sogdian_range32[] = { - { 69376, 69415 }, +static const URange32 Bhaiksuki_range32[] = { + { 72704, 72712 }, + { 72714, 72758 }, + { 72760, 72773 }, + { 72784, 72812 }, }; -static const URange16 Tagalog_range16[] = { - { 5888, 5900 }, - { 5902, 5908 }, +static const URange16 Bopomofo_range16[] = { + { 746, 747 }, + { 12549, 12591 }, + { 12704, 12730 }, }; -static const URange16 Malayalam_range16[] = { - { 3328, 3331 }, - { 3333, 3340 }, - { 3342, 3344 }, - { 3346, 3396 }, - { 3398, 3400 }, - { 3402, 3407 }, - { 3412, 3427 }, - { 3430, 3455 }, +static const URange32 Brahmi_range32[] = { + { 69632, 69709 }, + { 69714, 69743 }, + { 69759, 69759 }, }; -static const URange32 Marchen_range32[] = { - { 72816, 72847 }, - { 72850, 72871 }, - { 72873, 72886 }, +static const URange16 Braille_range16[] = { + { 10240, 10495 }, +}; +static const URange16 Buginese_range16[] = { + { 6656, 6683 }, + { 6686, 6687 }, +}; +static const URange16 Buhid_range16[] = { + { 5952, 5971 }, +}; +static const URange16 Canadian_Aboriginal_range16[] = { + { 5120, 5759 }, + { 6320, 6389 }, }; static const URange32 Carian_range32[] = { { 66208, 66256 }, }; -static const URange16 Hiragana_range16[] = { - { 12353, 12438 }, - { 12445, 12447 }, -}; -static const URange32 Hiragana_range32[] = { - { 110593, 110878 }, - { 127488, 127488 }, +static const URange32 Caucasian_Albanian_range32[] = { + { 66864, 66915 }, + { 66927, 66927 }, }; -static const URange16 Tagbanwa_range16[] = { - { 5984, 5996 }, - { 5998, 6000 }, - { 6002, 6003 }, +static const URange32 Chakma_range32[] = { + { 69888, 69940 }, + { 69942, 69958 }, }; -static const URange16 Meetei_Mayek_range16[] = { - { 43744, 43766 }, - { 43968, 44013 }, - { 44016, 44025 }, +static const URange16 Cham_range16[] = { + { 43520, 43574 }, + { 43584, 43597 }, + { 43600, 43609 }, + { 43612, 43615 }, }; -static const URange32 Hanifi_Rohingya_range32[] = { - { 68864, 68903 }, - { 68912, 68921 }, +static const URange16 Cherokee_range16[] = { + { 5024, 5109 }, + { 5112, 5117 }, + { 43888, 43967 }, }; -static const URange32 Pahawh_Hmong_range32[] = { - { 92928, 92997 }, - { 93008, 93017 }, - { 93019, 93025 }, - { 93027, 93047 }, - { 93053, 93071 }, +static const URange16 Common_range16[] = { + { 0, 64 }, + { 91, 96 }, + { 123, 169 }, + { 171, 185 }, + { 187, 191 }, + { 215, 215 }, + { 247, 247 }, + { 697, 735 }, + { 741, 745 }, + { 748, 767 }, + { 884, 884 }, + { 894, 894 }, + { 901, 901 }, + { 903, 903 }, + { 1417, 1417 }, + { 1541, 1541 }, + { 1548, 1548 }, + { 1563, 1563 }, + { 1567, 1567 }, + { 1600, 1600 }, + { 1757, 1757 }, + { 2274, 2274 }, + { 2404, 2405 }, + { 3647, 3647 }, + { 4053, 4056 }, + { 4347, 4347 }, + { 5867, 5869 }, + { 5941, 5942 }, + { 6146, 6147 }, + { 6149, 6149 }, + { 7379, 7379 }, + { 7393, 7393 }, + { 7401, 7404 }, + { 7406, 7411 }, + { 7413, 7415 }, + { 7418, 7418 }, + { 8192, 8203 }, + { 8206, 8292 }, + { 8294, 8304 }, + { 8308, 8318 }, + { 8320, 8334 }, + { 8352, 8383 }, + { 8448, 8485 }, + { 8487, 8489 }, + { 8492, 8497 }, + { 8499, 8525 }, + { 8527, 8543 }, + { 8585, 8587 }, + { 8592, 9254 }, + { 9280, 9290 }, + { 9312, 10239 }, + { 10496, 11123 }, + { 11126, 11157 }, + { 11160, 11263 }, + { 11776, 11855 }, + { 12272, 12283 }, + { 12288, 12292 }, + { 12294, 12294 }, + { 12296, 12320 }, + { 12336, 12343 }, + { 12348, 12351 }, + { 12443, 12444 }, + { 12448, 12448 }, + { 12539, 12540 }, + { 12688, 12703 }, + { 12736, 12771 }, + { 12832, 12895 }, + { 12927, 13007 }, + { 13055, 13055 }, + { 13144, 13311 }, + { 19904, 19967 }, + { 42752, 42785 }, + { 42888, 42890 }, + { 43056, 43065 }, + { 43310, 43310 }, + { 43471, 43471 }, + { 43867, 43867 }, + { 64830, 64831 }, + { 65040, 65049 }, + { 65072, 65106 }, + { 65108, 65126 }, + { 65128, 65131 }, + { 65279, 65279 }, + { 65281, 65312 }, + { 65339, 65344 }, + { 65371, 65381 }, + { 65392, 65392 }, + { 65438, 65439 }, + { 65504, 65510 }, + { 65512, 65518 }, + { 65529, 65533 }, }; -static const URange16 Tai_Le_range16[] = { - { 6480, 6509 }, - { 6512, 6516 }, +static const URange32 Common_range32[] = { + { 65792, 65794 }, + { 65799, 65843 }, + { 65847, 65855 }, + { 65936, 65947 }, + { 66000, 66044 }, + { 66273, 66299 }, + { 94178, 94179 }, + { 113824, 113827 }, + { 118784, 119029 }, + { 119040, 119078 }, + { 119081, 119142 }, + { 119146, 119162 }, + { 119171, 119172 }, + { 119180, 119209 }, + { 119214, 119272 }, + { 119520, 119539 }, + { 119552, 119638 }, + { 119648, 119672 }, + { 119808, 119892 }, + { 119894, 119964 }, + { 119966, 119967 }, + { 119970, 119970 }, + { 119973, 119974 }, + { 119977, 119980 }, + { 119982, 119993 }, + { 119995, 119995 }, + { 119997, 120003 }, + { 120005, 120069 }, + { 120071, 120074 }, + { 120077, 120084 }, + { 120086, 120092 }, + { 120094, 120121 }, + { 120123, 120126 }, + { 120128, 120132 }, + { 120134, 120134 }, + { 120138, 120144 }, + { 120146, 120485 }, + { 120488, 120779 }, + { 120782, 120831 }, + { 126065, 126132 }, + { 126209, 126269 }, + { 126976, 127019 }, + { 127024, 127123 }, + { 127136, 127150 }, + { 127153, 127167 }, + { 127169, 127183 }, + { 127185, 127221 }, + { 127232, 127244 }, + { 127248, 127340 }, + { 127344, 127404 }, + { 127462, 127487 }, + { 127489, 127490 }, + { 127504, 127547 }, + { 127552, 127560 }, + { 127568, 127569 }, + { 127584, 127589 }, + { 127744, 128725 }, + { 128736, 128748 }, + { 128752, 128762 }, + { 128768, 128883 }, + { 128896, 128984 }, + { 128992, 129003 }, + { 129024, 129035 }, + { 129040, 129095 }, + { 129104, 129113 }, + { 129120, 129159 }, + { 129168, 129197 }, + { 129280, 129291 }, + { 129293, 129393 }, + { 129395, 129398 }, + { 129402, 129442 }, + { 129445, 129450 }, + { 129454, 129482 }, + { 129485, 129619 }, + { 129632, 129645 }, + { 129648, 129651 }, + { 129656, 129658 }, + { 129664, 129666 }, + { 129680, 129685 }, + { 917505, 917505 }, + { 917536, 917631 }, }; -static const URange16 Kayah_Li_range16[] = { - { 43264, 43309 }, - { 43311, 43311 }, +static const URange16 Coptic_range16[] = { + { 994, 1007 }, + { 11392, 11507 }, + { 11513, 11519 }, }; -static const URange16 Buginese_range16[] = { - { 6656, 6683 }, - { 6686, 6687 }, +static const URange32 Cuneiform_range32[] = { + { 73728, 74649 }, + { 74752, 74862 }, + { 74864, 74868 }, + { 74880, 75075 }, }; -static const URange32 Kharoshthi_range32[] = { - { 68096, 68099 }, - { 68101, 68102 }, - { 68108, 68115 }, - { 68117, 68119 }, - { 68121, 68149 }, - { 68152, 68154 }, - { 68159, 68168 }, - { 68176, 68184 }, +static const URange32 Cypriot_range32[] = { + { 67584, 67589 }, + { 67592, 67592 }, + { 67594, 67637 }, + { 67639, 67640 }, + { 67644, 67644 }, + { 67647, 67647 }, }; -static const URange16 Tai_Tham_range16[] = { - { 6688, 6750 }, - { 6752, 6780 }, - { 6783, 6793 }, - { 6800, 6809 }, - { 6816, 6829 }, +static const URange16 Cyrillic_range16[] = { + { 1024, 1156 }, + { 1159, 1327 }, + { 7296, 7304 }, + { 7467, 7467 }, + { 7544, 7544 }, + { 11744, 11775 }, + { 42560, 42655 }, + { 65070, 65071 }, }; -static const URange32 Old_Italic_range32[] = { - { 66304, 66339 }, - { 66349, 66351 }, +static const URange32 Deseret_range32[] = { + { 66560, 66639 }, }; -static const URange32 Old_Persian_range32[] = { - { 66464, 66499 }, - { 66504, 66517 }, +static const URange16 Devanagari_range16[] = { + { 2304, 2384 }, + { 2389, 2403 }, + { 2406, 2431 }, + { 43232, 43263 }, }; -static const URange32 Warang_Citi_range32[] = { - { 71840, 71922 }, - { 71935, 71935 }, +static const URange32 Dogra_range32[] = { + { 71680, 71739 }, +}; +static const URange32 Duployan_range32[] = { + { 113664, 113770 }, + { 113776, 113788 }, + { 113792, 113800 }, + { 113808, 113817 }, + { 113820, 113823 }, }; -static const URange16 Latin_range16[] = { - { 65, 90 }, - { 97, 122 }, - { 170, 170 }, - { 186, 186 }, - { 192, 214 }, - { 216, 246 }, - { 248, 696 }, - { 736, 740 }, - { 7424, 7461 }, - { 7468, 7516 }, - { 7522, 7525 }, - { 7531, 7543 }, - { 7545, 7614 }, - { 7680, 7935 }, - { 8305, 8305 }, - { 8319, 8319 }, - { 8336, 8348 }, - { 8490, 8491 }, - { 8498, 8498 }, - { 8526, 8526 }, - { 8544, 8584 }, - { 11360, 11391 }, - { 42786, 42887 }, - { 42891, 42937 }, - { 42999, 43007 }, - { 43824, 43866 }, - { 43868, 43876 }, - { 64256, 64262 }, - { 65313, 65338 }, - { 65345, 65370 }, +static const URange32 Egyptian_Hieroglyphs_range32[] = { + { 77824, 78894 }, + { 78896, 78904 }, }; -static const URange16 Saurashtra_range16[] = { - { 43136, 43205 }, - { 43214, 43225 }, +static const URange32 Elbasan_range32[] = { + { 66816, 66855 }, }; -static const URange32 Shavian_range32[] = { - { 66640, 66687 }, +static const URange32 Elymaic_range32[] = { + { 69600, 69622 }, +}; +static const URange16 Ethiopic_range16[] = { + { 4608, 4680 }, + { 4682, 4685 }, + { 4688, 4694 }, + { 4696, 4696 }, + { 4698, 4701 }, + { 4704, 4744 }, + { 4746, 4749 }, + { 4752, 4784 }, + { 4786, 4789 }, + { 4792, 4798 }, + { 4800, 4800 }, + { 4802, 4805 }, + { 4808, 4822 }, + { 4824, 4880 }, + { 4882, 4885 }, + { 4888, 4954 }, + { 4957, 4988 }, + { 4992, 5017 }, + { 11648, 11670 }, + { 11680, 11686 }, + { 11688, 11694 }, + { 11696, 11702 }, + { 11704, 11710 }, + { 11712, 11718 }, + { 11720, 11726 }, + { 11728, 11734 }, + { 11736, 11742 }, + { 43777, 43782 }, + { 43785, 43790 }, + { 43793, 43798 }, + { 43808, 43814 }, + { 43816, 43822 }, }; static const URange16 Georgian_range16[] = { { 4256, 4293 }, @@ -5017,6 +5189,20 @@ static const URange16 Georgian_range16[] = { { 11559, 11559 }, { 11565, 11565 }, }; +static const URange16 Glagolitic_range16[] = { + { 11264, 11310 }, + { 11312, 11358 }, +}; +static const URange32 Glagolitic_range32[] = { + { 122880, 122886 }, + { 122888, 122904 }, + { 122907, 122913 }, + { 122915, 122916 }, + { 122918, 122922 }, +}; +static const URange32 Gothic_range32[] = { + { 66352, 66378 }, +}; static const URange32 Grantha_range32[] = { { 70400, 70403 }, { 70405, 70412 }, @@ -5034,51 +5220,6 @@ static const URange32 Grantha_range32[] = { { 70502, 70508 }, { 70512, 70516 }, }; -static const URange32 Duployan_range32[] = { - { 113664, 113770 }, - { 113776, 113788 }, - { 113792, 113800 }, - { 113808, 113817 }, - { 113820, 113823 }, -}; -static const URange16 Batak_range16[] = { - { 7104, 7155 }, - { 7164, 7167 }, -}; -static const URange16 Devanagari_range16[] = { - { 2304, 2384 }, - { 2387, 2403 }, - { 2406, 2431 }, - { 43232, 43263 }, -}; -static const URange16 Thai_range16[] = { - { 3585, 3642 }, - { 3648, 3675 }, -}; -static const URange16 Tibetan_range16[] = { - { 3840, 3911 }, - { 3913, 3948 }, - { 3953, 3991 }, - { 3993, 4028 }, - { 4030, 4044 }, - { 4046, 4052 }, - { 4057, 4058 }, -}; -static const URange16 Tifinagh_range16[] = { - { 11568, 11623 }, - { 11631, 11632 }, - { 11647, 11647 }, -}; -static const URange32 Ugaritic_range32[] = { - { 66432, 66461 }, - { 66463, 66463 }, -}; -static const URange16 Braille_range16[] = { - { 10240, 10495 }, -}; -static const URange32 Anatolian_Hieroglyphs_range32[] = { - { 82944, 83526 }, -}; static const URange16 Greek_range16[] = { { 880, 883 }, { 885, 887 }, @@ -5119,48 +5260,184 @@ static const URange32 Greek_range32[] = { { 65952, 65952 }, { 119296, 119365 }, }; -static const URange32 Lycian_range32[] = { - { 66176, 66204 }, +static const URange16 Gujarati_range16[] = { + { 2689, 2691 }, + { 2693, 2701 }, + { 2703, 2705 }, + { 2707, 2728 }, + { 2730, 2736 }, + { 2738, 2739 }, + { 2741, 2745 }, + { 2748, 2757 }, + { 2759, 2761 }, + { 2763, 2765 }, + { 2768, 2768 }, + { 2784, 2787 }, + { 2790, 2801 }, + { 2809, 2815 }, }; -static const URange32 Mende_Kikakui_range32[] = { - { 124928, 125124 }, - { 125127, 125142 }, +static const URange32 Gunjala_Gondi_range32[] = { + { 73056, 73061 }, + { 73063, 73064 }, + { 73066, 73102 }, + { 73104, 73105 }, + { 73107, 73112 }, + { 73120, 73129 }, }; -static const URange16 Tai_Viet_range16[] = { - { 43648, 43714 }, - { 43739, 43743 }, +static const URange16 Gurmukhi_range16[] = { + { 2561, 2563 }, + { 2565, 2570 }, + { 2575, 2576 }, + { 2579, 2600 }, + { 2602, 2608 }, + { 2610, 2611 }, + { 2613, 2614 }, + { 2616, 2617 }, + { 2620, 2620 }, + { 2622, 2626 }, + { 2631, 2632 }, + { 2635, 2637 }, + { 2641, 2641 }, + { 2649, 2652 }, + { 2654, 2654 }, + { 2662, 2678 }, +}; +static const URange16 Han_range16[] = { + { 11904, 11929 }, + { 11931, 12019 }, + { 12032, 12245 }, + { 12293, 12293 }, + { 12295, 12295 }, + { 12321, 12329 }, + { 12344, 12347 }, + { 13312, 19893 }, + { 19968, 40943 }, + { 63744, 64109 }, + { 64112, 64217 }, +}; +static const URange32 Han_range32[] = { + { 131072, 173782 }, + { 173824, 177972 }, + { 177984, 178205 }, + { 178208, 183969 }, + { 183984, 191456 }, + { 194560, 195101 }, +}; +static const URange16 Hangul_range16[] = { + { 4352, 4607 }, + { 12334, 12335 }, + { 12593, 12686 }, + { 12800, 12830 }, + { 12896, 12926 }, + { 43360, 43388 }, + { 44032, 55203 }, + { 55216, 55238 }, + { 55243, 55291 }, + { 65440, 65470 }, + { 65474, 65479 }, + { 65482, 65487 }, + { 65490, 65495 }, + { 65498, 65500 }, +}; +static const URange32 Hanifi_Rohingya_range32[] = { + { 68864, 68903 }, + { 68912, 68921 }, +}; +static const URange16 Hanunoo_range16[] = { + { 5920, 5940 }, +}; +static const URange32 Hatran_range32[] = { + { 67808, 67826 }, + { 67828, 67829 }, + { 67835, 67839 }, +}; +static const URange16 Hebrew_range16[] = { + { 1425, 1479 }, + { 1488, 1514 }, + { 1519, 1524 }, + { 64285, 64310 }, + { 64312, 64316 }, + { 64318, 64318 }, + { 64320, 64321 }, + { 64323, 64324 }, + { 64326, 64335 }, +}; +static const URange16 Hiragana_range16[] = { + { 12353, 12438 }, + { 12445, 12447 }, +}; +static const URange32 Hiragana_range32[] = { + { 110593, 110878 }, + { 110928, 110930 }, + { 127488, 127488 }, +}; +static const URange32 Imperial_Aramaic_range32[] = { + { 67648, 67669 }, + { 67671, 67679 }, +}; +static const URange16 Inherited_range16[] = { + { 768, 879 }, + { 1157, 1158 }, + { 1611, 1621 }, + { 1648, 1648 }, + { 2385, 2388 }, + { 6832, 6846 }, + { 7376, 7378 }, + { 7380, 7392 }, + { 7394, 7400 }, + { 7405, 7405 }, + { 7412, 7412 }, + { 7416, 7417 }, + { 7616, 7673 }, + { 7675, 7679 }, + { 8204, 8205 }, + { 8400, 8432 }, + { 12330, 12333 }, + { 12441, 12442 }, + { 65024, 65039 }, + { 65056, 65069 }, }; -static const URange16 Vai_range16[] = { - { 42240, 42539 }, +static const URange32 Inherited_range32[] = { + { 66045, 66045 }, + { 66272, 66272 }, + { 70459, 70459 }, + { 119143, 119145 }, + { 119163, 119170 }, + { 119173, 119179 }, + { 119210, 119213 }, + { 917760, 917999 }, }; -static const URange16 Ogham_range16[] = { - { 5760, 5788 }, +static const URange32 Inscriptional_Pahlavi_range32[] = { + { 68448, 68466 }, + { 68472, 68479 }, }; static const URange32 Inscriptional_Parthian_range32[] = { { 68416, 68437 }, { 68440, 68447 }, }; -static const URange16 Cham_range16[] = { - { 43520, 43574 }, - { 43584, 43597 }, - { 43600, 43609 }, - { 43612, 43615 }, -}; -static const URange16 Syriac_range16[] = { - { 1792, 1805 }, - { 1807, 1866 }, - { 1869, 1871 }, - { 2144, 2154 }, -}; -static const URange16 Runic_range16[] = { - { 5792, 5866 }, - { 5870, 5880 }, +static const URange16 Javanese_range16[] = { + { 43392, 43469 }, + { 43472, 43481 }, + { 43486, 43487 }, }; -static const URange32 Gothic_range32[] = { - { 66352, 66378 }, +static const URange32 Kaithi_range32[] = { + { 69760, 69825 }, + { 69837, 69837 }, }; -static const URange32 Mahajani_range32[] = { - { 69968, 70006 }, +static const URange16 Kannada_range16[] = { + { 3200, 3212 }, + { 3214, 3216 }, + { 3218, 3240 }, + { 3242, 3251 }, + { 3253, 3257 }, + { 3260, 3268 }, + { 3270, 3272 }, + { 3274, 3277 }, + { 3285, 3286 }, + { 3294, 3294 }, + { 3296, 3299 }, + { 3302, 3311 }, + { 3313, 3314 }, }; static const URange16 Katakana_range16[] = { { 12449, 12538 }, @@ -5173,107 +5450,21 @@ static const URange16 Katakana_range16[] = { }; static const URange32 Katakana_range32[] = { { 110592, 110592 }, + { 110948, 110951 }, }; -static const URange32 Osmanya_range32[] = { - { 66688, 66717 }, - { 66720, 66729 }, -}; -static const URange16 New_Tai_Lue_range16[] = { - { 6528, 6571 }, - { 6576, 6601 }, - { 6608, 6618 }, - { 6622, 6623 }, -}; -static const URange16 Ol_Chiki_range16[] = { - { 7248, 7295 }, -}; -static const URange32 Newa_range32[] = { - { 70656, 70745 }, - { 70747, 70747 }, - { 70749, 70750 }, -}; -static const URange16 Limbu_range16[] = { - { 6400, 6430 }, - { 6432, 6443 }, - { 6448, 6459 }, - { 6464, 6464 }, - { 6468, 6479 }, -}; -static const URange32 Pau_Cin_Hau_range32[] = { - { 72384, 72440 }, -}; -static const URange16 Cherokee_range16[] = { - { 5024, 5109 }, - { 5112, 5117 }, - { 43888, 43967 }, -}; -static const URange32 Miao_range32[] = { - { 93952, 94020 }, - { 94032, 94078 }, - { 94095, 94111 }, -}; -static const URange16 Oriya_range16[] = { - { 2817, 2819 }, - { 2821, 2828 }, - { 2831, 2832 }, - { 2835, 2856 }, - { 2858, 2864 }, - { 2866, 2867 }, - { 2869, 2873 }, - { 2876, 2884 }, - { 2887, 2888 }, - { 2891, 2893 }, - { 2902, 2903 }, - { 2908, 2909 }, - { 2911, 2915 }, - { 2918, 2935 }, -}; -static const URange32 Medefaidrin_range32[] = { - { 93760, 93850 }, -}; -static const URange32 Sharada_range32[] = { - { 70016, 70093 }, - { 70096, 70111 }, -}; -static const URange16 Gujarati_range16[] = { - { 2689, 2691 }, - { 2693, 2701 }, - { 2703, 2705 }, - { 2707, 2728 }, - { 2730, 2736 }, - { 2738, 2739 }, - { 2741, 2745 }, - { 2748, 2757 }, - { 2759, 2761 }, - { 2763, 2765 }, - { 2768, 2768 }, - { 2784, 2787 }, - { 2790, 2801 }, - { 2809, 2815 }, -}; -static const URange32 Nushu_range32[] = { - { 94177, 94177 }, - { 110960, 111355 }, -}; -static const URange32 Modi_range32[] = { - { 71168, 71236 }, - { 71248, 71257 }, -}; -static const URange32 Gunjala_Gondi_range32[] = { - { 73056, 73061 }, - { 73063, 73064 }, - { 73066, 73102 }, - { 73104, 73105 }, - { 73107, 73112 }, - { 73120, 73129 }, -}; -static const URange32 Inscriptional_Pahlavi_range32[] = { - { 68448, 68466 }, - { 68472, 68479 }, +static const URange16 Kayah_Li_range16[] = { + { 43264, 43309 }, + { 43311, 43311 }, }; -static const URange32 Manichaean_range32[] = { - { 68288, 68326 }, - { 68331, 68342 }, +static const URange32 Kharoshthi_range32[] = { + { 68096, 68099 }, + { 68101, 68102 }, + { 68108, 68115 }, + { 68117, 68119 }, + { 68121, 68149 }, + { 68152, 68154 }, + { 68159, 68168 }, + { 68176, 68184 }, }; static const URange16 Khmer_range16[] = { { 6016, 6109 }, @@ -5281,141 +5472,163 @@ static const URange16 Khmer_range16[] = { { 6128, 6137 }, { 6624, 6655 }, }; -static const URange32 Cuneiform_range32[] = { - { 73728, 74649 }, - { 74752, 74862 }, - { 74864, 74868 }, - { 74880, 75075 }, +static const URange32 Khojki_range32[] = { + { 70144, 70161 }, + { 70163, 70206 }, }; static const URange32 Khudawadi_range32[] = { { 70320, 70378 }, { 70384, 70393 }, }; -static const URange16 Mandaic_range16[] = { - { 2112, 2139 }, - { 2142, 2142 }, +static const URange16 Lao_range16[] = { + { 3713, 3714 }, + { 3716, 3716 }, + { 3718, 3722 }, + { 3724, 3747 }, + { 3749, 3749 }, + { 3751, 3773 }, + { 3776, 3780 }, + { 3782, 3782 }, + { 3784, 3789 }, + { 3792, 3801 }, + { 3804, 3807 }, }; -static const URange32 Hatran_range32[] = { - { 67808, 67826 }, - { 67828, 67829 }, - { 67835, 67839 }, +static const URange16 Latin_range16[] = { + { 65, 90 }, + { 97, 122 }, + { 170, 170 }, + { 186, 186 }, + { 192, 214 }, + { 216, 246 }, + { 248, 696 }, + { 736, 740 }, + { 7424, 7461 }, + { 7468, 7516 }, + { 7522, 7525 }, + { 7531, 7543 }, + { 7545, 7614 }, + { 7680, 7935 }, + { 8305, 8305 }, + { 8319, 8319 }, + { 8336, 8348 }, + { 8490, 8491 }, + { 8498, 8498 }, + { 8526, 8526 }, + { 8544, 8584 }, + { 11360, 11391 }, + { 42786, 42887 }, + { 42891, 42943 }, + { 42946, 42950 }, + { 42999, 43007 }, + { 43824, 43866 }, + { 43868, 43876 }, + { 43878, 43879 }, + { 64256, 64262 }, + { 65313, 65338 }, + { 65345, 65370 }, }; -static const URange16 Syloti_Nagri_range16[] = { - { 43008, 43051 }, +static const URange16 Lepcha_range16[] = { + { 7168, 7223 }, + { 7227, 7241 }, + { 7245, 7247 }, }; -static const URange16 Nko_range16[] = { - { 1984, 2042 }, - { 2045, 2047 }, +static const URange16 Limbu_range16[] = { + { 6400, 6430 }, + { 6432, 6443 }, + { 6448, 6459 }, + { 6464, 6464 }, + { 6468, 6479 }, +}; +static const URange32 Linear_A_range32[] = { + { 67072, 67382 }, + { 67392, 67413 }, + { 67424, 67431 }, +}; +static const URange32 Linear_B_range32[] = { + { 65536, 65547 }, + { 65549, 65574 }, + { 65576, 65594 }, + { 65596, 65597 }, + { 65599, 65613 }, + { 65616, 65629 }, + { 65664, 65786 }, }; -static const URange16 Canadian_Aboriginal_range16[] = { - { 5120, 5759 }, - { 6320, 6389 }, +static const URange16 Lisu_range16[] = { + { 42192, 42239 }, }; -static const URange32 Meroitic_Hieroglyphs_range32[] = { - { 67968, 67999 }, +static const URange32 Lycian_range32[] = { + { 66176, 66204 }, }; -static const URange32 Phoenician_range32[] = { - { 67840, 67867 }, - { 67871, 67871 }, +static const URange32 Lydian_range32[] = { + { 67872, 67897 }, + { 67903, 67903 }, }; -static const URange32 Nabataean_range32[] = { - { 67712, 67742 }, - { 67751, 67759 }, +static const URange32 Mahajani_range32[] = { + { 69968, 70006 }, }; -static const URange16 Bengali_range16[] = { - { 2432, 2435 }, - { 2437, 2444 }, - { 2447, 2448 }, - { 2451, 2472 }, - { 2474, 2480 }, - { 2482, 2482 }, - { 2486, 2489 }, - { 2492, 2500 }, - { 2503, 2504 }, - { 2507, 2510 }, - { 2519, 2519 }, - { 2524, 2525 }, - { 2527, 2531 }, - { 2534, 2558 }, +static const URange32 Makasar_range32[] = { + { 73440, 73464 }, }; -static const URange32 Kaithi_range32[] = { - { 69760, 69825 }, - { 69837, 69837 }, +static const URange16 Malayalam_range16[] = { + { 3328, 3331 }, + { 3333, 3340 }, + { 3342, 3344 }, + { 3346, 3396 }, + { 3398, 3400 }, + { 3402, 3407 }, + { 3412, 3427 }, + { 3430, 3455 }, }; -static const URange16 Glagolitic_range16[] = { - { 11264, 11310 }, - { 11312, 11358 }, +static const URange16 Mandaic_range16[] = { + { 2112, 2139 }, + { 2142, 2142 }, }; -static const URange32 Glagolitic_range32[] = { - { 122880, 122886 }, - { 122888, 122904 }, - { 122907, 122913 }, - { 122915, 122916 }, - { 122918, 122922 }, +static const URange32 Manichaean_range32[] = { + { 68288, 68326 }, + { 68331, 68342 }, }; -static const URange32 Imperial_Aramaic_range32[] = { - { 67648, 67669 }, - { 67671, 67679 }, +static const URange32 Marchen_range32[] = { + { 72816, 72847 }, + { 72850, 72871 }, + { 72873, 72886 }, }; -static const URange32 Sora_Sompeng_range32[] = { - { 69840, 69864 }, - { 69872, 69881 }, +static const URange32 Masaram_Gondi_range32[] = { + { 72960, 72966 }, + { 72968, 72969 }, + { 72971, 73014 }, + { 73018, 73018 }, + { 73020, 73021 }, + { 73023, 73031 }, + { 73040, 73049 }, }; -static const URange16 Gurmukhi_range16[] = { - { 2561, 2563 }, - { 2565, 2570 }, - { 2575, 2576 }, - { 2579, 2600 }, - { 2602, 2608 }, - { 2610, 2611 }, - { 2613, 2614 }, - { 2616, 2617 }, - { 2620, 2620 }, - { 2622, 2626 }, - { 2631, 2632 }, - { 2635, 2637 }, - { 2641, 2641 }, - { 2649, 2652 }, - { 2654, 2654 }, - { 2662, 2678 }, +static const URange32 Medefaidrin_range32[] = { + { 93760, 93850 }, }; -static const URange16 Javanese_range16[] = { - { 43392, 43469 }, - { 43472, 43481 }, - { 43486, 43487 }, +static const URange16 Meetei_Mayek_range16[] = { + { 43744, 43766 }, + { 43968, 44013 }, + { 44016, 44025 }, }; -static const URange32 Old_Permic_range32[] = { - { 66384, 66426 }, +static const URange32 Mende_Kikakui_range32[] = { + { 124928, 125124 }, + { 125127, 125142 }, }; -static const URange16 Phags_Pa_range16[] = { - { 43072, 43127 }, +static const URange32 Meroitic_Cursive_range32[] = { + { 68000, 68023 }, + { 68028, 68047 }, + { 68050, 68095 }, }; -static const URange32 Cypriot_range32[] = { - { 67584, 67589 }, - { 67592, 67592 }, - { 67594, 67637 }, - { 67639, 67640 }, - { 67644, 67644 }, - { 67647, 67647 }, +static const URange32 Meroitic_Hieroglyphs_range32[] = { + { 67968, 67999 }, }; -static const URange16 Kannada_range16[] = { - { 3200, 3212 }, - { 3214, 3216 }, - { 3218, 3240 }, - { 3242, 3251 }, - { 3253, 3257 }, - { 3260, 3268 }, - { 3270, 3272 }, - { 3274, 3277 }, - { 3285, 3286 }, - { 3294, 3294 }, - { 3296, 3299 }, - { 3302, 3311 }, - { 3313, 3314 }, +static const URange32 Miao_range32[] = { + { 93952, 94026 }, + { 94031, 94087 }, + { 94095, 94111 }, }; -static const URange32 Khojki_range32[] = { - { 70144, 70161 }, - { 70163, 70206 }, +static const URange32 Modi_range32[] = { + { 71168, 71236 }, + { 71248, 71257 }, }; static const URange16 Mongolian_range16[] = { { 6144, 6145 }, @@ -5428,42 +5641,10 @@ static const URange16 Mongolian_range16[] = { static const URange32 Mongolian_range32[] = { { 71264, 71276 }, }; -static const URange16 Sinhala_range16[] = { - { 3458, 3459 }, - { 3461, 3478 }, - { 3482, 3505 }, - { 3507, 3515 }, - { 3517, 3517 }, - { 3520, 3526 }, - { 3530, 3530 }, - { 3535, 3540 }, - { 3542, 3542 }, - { 3544, 3551 }, - { 3558, 3567 }, - { 3570, 3572 }, -}; -static const URange32 Sinhala_range32[] = { - { 70113, 70132 }, -}; -static const URange32 Brahmi_range32[] = { - { 69632, 69709 }, - { 69714, 69743 }, - { 69759, 69759 }, -}; -static const URange32 Elbasan_range32[] = { - { 66816, 66855 }, -}; -static const URange32 Deseret_range32[] = { - { 66560, 66639 }, -}; -static const URange16 Rejang_range16[] = { - { 43312, 43347 }, - { 43359, 43359 }, -}; -static const URange32 SignWriting_range32[] = { - { 120832, 121483 }, - { 121499, 121503 }, - { 121505, 121519 }, +static const URange32 Mro_range32[] = { + { 92736, 92766 }, + { 92768, 92777 }, + { 92782, 92783 }, }; static const URange32 Multani_range32[] = { { 70272, 70278 }, @@ -5472,399 +5653,317 @@ static const URange32 Multani_range32[] = { { 70287, 70301 }, { 70303, 70313 }, }; -static const URange16 Yi_range16[] = { - { 40960, 42124 }, - { 42128, 42182 }, -}; -static const URange16 Balinese_range16[] = { - { 6912, 6987 }, - { 6992, 7036 }, -}; -static const URange16 Lao_range16[] = { - { 3713, 3714 }, - { 3716, 3716 }, - { 3719, 3720 }, - { 3722, 3722 }, - { 3725, 3725 }, - { 3732, 3735 }, - { 3737, 3743 }, - { 3745, 3747 }, - { 3749, 3749 }, - { 3751, 3751 }, - { 3754, 3755 }, - { 3757, 3769 }, - { 3771, 3773 }, - { 3776, 3780 }, - { 3782, 3782 }, - { 3784, 3789 }, - { 3792, 3801 }, - { 3804, 3807 }, -}; -static const URange16 Hanunoo_range16[] = { - { 5920, 5940 }, -}; -static const URange32 Masaram_Gondi_range32[] = { - { 72960, 72966 }, - { 72968, 72969 }, - { 72971, 73014 }, - { 73018, 73018 }, - { 73020, 73021 }, - { 73023, 73031 }, - { 73040, 73049 }, -}; -static const URange32 Linear_B_range32[] = { - { 65536, 65547 }, - { 65549, 65574 }, - { 65576, 65594 }, - { 65596, 65597 }, - { 65599, 65613 }, - { 65616, 65629 }, - { 65664, 65786 }, +static const URange16 Myanmar_range16[] = { + { 4096, 4255 }, + { 43488, 43518 }, + { 43616, 43647 }, }; -static const URange32 Linear_A_range32[] = { - { 67072, 67382 }, - { 67392, 67413 }, - { 67424, 67431 }, +static const URange32 Nabataean_range32[] = { + { 67712, 67742 }, + { 67751, 67759 }, }; -static const URange32 Dogra_range32[] = { - { 71680, 71739 }, +static const URange32 Nandinagari_range32[] = { + { 72096, 72103 }, + { 72106, 72151 }, + { 72154, 72164 }, }; -static const URange32 Old_Turkic_range32[] = { - { 68608, 68680 }, +static const URange16 New_Tai_Lue_range16[] = { + { 6528, 6571 }, + { 6576, 6601 }, + { 6608, 6618 }, + { 6622, 6623 }, }; -static const URange16 Lepcha_range16[] = { - { 7168, 7223 }, - { 7227, 7241 }, - { 7245, 7247 }, +static const URange32 Newa_range32[] = { + { 70656, 70745 }, + { 70747, 70747 }, + { 70749, 70751 }, }; -static const URange32 Lydian_range32[] = { - { 67872, 67897 }, - { 67903, 67903 }, +static const URange16 Nko_range16[] = { + { 1984, 2042 }, + { 2045, 2047 }, }; -static const URange32 Egyptian_Hieroglyphs_range32[] = { - { 77824, 78894 }, +static const URange32 Nushu_range32[] = { + { 94177, 94177 }, + { 110960, 111355 }, }; -static const URange32 Sogdian_range32[] = { - { 69424, 69465 }, +static const URange32 Nyiakeng_Puachue_Hmong_range32[] = { + { 123136, 123180 }, + { 123184, 123197 }, + { 123200, 123209 }, + { 123214, 123215 }, }; -static const URange32 Caucasian_Albanian_range32[] = { - { 66864, 66915 }, - { 66927, 66927 }, +static const URange16 Ogham_range16[] = { + { 5760, 5788 }, }; -static const URange32 Makasar_range32[] = { - { 73440, 73464 }, +static const URange16 Ol_Chiki_range16[] = { + { 7248, 7295 }, }; static const URange32 Old_Hungarian_range32[] = { { 68736, 68786 }, { 68800, 68850 }, { 68858, 68863 }, }; -static const URange16 Samaritan_range16[] = { - { 2048, 2093 }, - { 2096, 2110 }, +static const URange32 Old_Italic_range32[] = { + { 66304, 66339 }, + { 66349, 66351 }, }; -static const URange16 Lisu_range16[] = { - { 42192, 42239 }, +static const URange32 Old_North_Arabian_range32[] = { + { 68224, 68255 }, }; -static const URange16 Buhid_range16[] = { - { 5952, 5971 }, +static const URange32 Old_Permic_range32[] = { + { 66384, 66426 }, +}; +static const URange32 Old_Persian_range32[] = { + { 66464, 66499 }, + { 66504, 66517 }, +}; +static const URange32 Old_Sogdian_range32[] = { + { 69376, 69415 }, +}; +static const URange32 Old_South_Arabian_range32[] = { + { 68192, 68223 }, +}; +static const URange32 Old_Turkic_range32[] = { + { 68608, 68680 }, +}; +static const URange16 Oriya_range16[] = { + { 2817, 2819 }, + { 2821, 2828 }, + { 2831, 2832 }, + { 2835, 2856 }, + { 2858, 2864 }, + { 2866, 2867 }, + { 2869, 2873 }, + { 2876, 2884 }, + { 2887, 2888 }, + { 2891, 2893 }, + { 2902, 2903 }, + { 2908, 2909 }, + { 2911, 2915 }, + { 2918, 2935 }, +}; +static const URange32 Osage_range32[] = { + { 66736, 66771 }, + { 66776, 66811 }, +}; +static const URange32 Osmanya_range32[] = { + { 66688, 66717 }, + { 66720, 66729 }, +}; +static const URange32 Pahawh_Hmong_range32[] = { + { 92928, 92997 }, + { 93008, 93017 }, + { 93019, 93025 }, + { 93027, 93047 }, + { 93053, 93071 }, }; static const URange32 Palmyrene_range32[] = { { 67680, 67711 }, }; -static const URange32 Tirhuta_range32[] = { - { 70784, 70855 }, - { 70864, 70873 }, -}; -static const URange32 Mro_range32[] = { - { 92736, 92766 }, - { 92768, 92777 }, - { 92782, 92783 }, +static const URange32 Pau_Cin_Hau_range32[] = { + { 72384, 72440 }, }; -static const URange16 Common_range16[] = { - { 0, 64 }, - { 91, 96 }, - { 123, 169 }, - { 171, 185 }, - { 187, 191 }, - { 215, 215 }, - { 247, 247 }, - { 697, 735 }, - { 741, 745 }, - { 748, 767 }, - { 884, 884 }, - { 894, 894 }, - { 901, 901 }, - { 903, 903 }, - { 1417, 1417 }, - { 1541, 1541 }, - { 1548, 1548 }, - { 1563, 1563 }, - { 1567, 1567 }, - { 1600, 1600 }, - { 1757, 1757 }, - { 2274, 2274 }, - { 2404, 2405 }, - { 3647, 3647 }, - { 4053, 4056 }, - { 4347, 4347 }, - { 5867, 5869 }, - { 5941, 5942 }, - { 6146, 6147 }, - { 6149, 6149 }, - { 7379, 7379 }, - { 7393, 7393 }, - { 7401, 7404 }, - { 7406, 7411 }, - { 7413, 7415 }, - { 8192, 8203 }, - { 8206, 8292 }, - { 8294, 8304 }, - { 8308, 8318 }, - { 8320, 8334 }, - { 8352, 8383 }, - { 8448, 8485 }, - { 8487, 8489 }, - { 8492, 8497 }, - { 8499, 8525 }, - { 8527, 8543 }, - { 8585, 8587 }, - { 8592, 9254 }, - { 9280, 9290 }, - { 9312, 10239 }, - { 10496, 11123 }, - { 11126, 11157 }, - { 11160, 11208 }, - { 11210, 11262 }, - { 11776, 11854 }, - { 12272, 12283 }, - { 12288, 12292 }, - { 12294, 12294 }, - { 12296, 12320 }, - { 12336, 12343 }, - { 12348, 12351 }, - { 12443, 12444 }, - { 12448, 12448 }, - { 12539, 12540 }, - { 12688, 12703 }, - { 12736, 12771 }, - { 12832, 12895 }, - { 12927, 13007 }, - { 13144, 13311 }, - { 19904, 19967 }, - { 42752, 42785 }, - { 42888, 42890 }, - { 43056, 43065 }, - { 43310, 43310 }, - { 43471, 43471 }, - { 43867, 43867 }, - { 64830, 64831 }, - { 65040, 65049 }, - { 65072, 65106 }, - { 65108, 65126 }, - { 65128, 65131 }, - { 65279, 65279 }, - { 65281, 65312 }, - { 65339, 65344 }, - { 65371, 65381 }, - { 65392, 65392 }, - { 65438, 65439 }, - { 65504, 65510 }, - { 65512, 65518 }, - { 65529, 65533 }, +static const URange16 Phags_Pa_range16[] = { + { 43072, 43127 }, }; -static const URange32 Common_range32[] = { - { 65792, 65794 }, - { 65799, 65843 }, - { 65847, 65855 }, - { 65936, 65947 }, - { 66000, 66044 }, - { 66273, 66299 }, - { 113824, 113827 }, - { 118784, 119029 }, - { 119040, 119078 }, - { 119081, 119142 }, - { 119146, 119162 }, - { 119171, 119172 }, - { 119180, 119209 }, - { 119214, 119272 }, - { 119520, 119539 }, - { 119552, 119638 }, - { 119648, 119672 }, - { 119808, 119892 }, - { 119894, 119964 }, - { 119966, 119967 }, - { 119970, 119970 }, - { 119973, 119974 }, - { 119977, 119980 }, - { 119982, 119993 }, - { 119995, 119995 }, - { 119997, 120003 }, - { 120005, 120069 }, - { 120071, 120074 }, - { 120077, 120084 }, - { 120086, 120092 }, - { 120094, 120121 }, - { 120123, 120126 }, - { 120128, 120132 }, - { 120134, 120134 }, - { 120138, 120144 }, - { 120146, 120485 }, - { 120488, 120779 }, - { 120782, 120831 }, - { 126065, 126132 }, - { 126976, 127019 }, - { 127024, 127123 }, - { 127136, 127150 }, - { 127153, 127167 }, - { 127169, 127183 }, - { 127185, 127221 }, - { 127232, 127244 }, - { 127248, 127339 }, - { 127344, 127404 }, - { 127462, 127487 }, - { 127489, 127490 }, - { 127504, 127547 }, - { 127552, 127560 }, - { 127568, 127569 }, - { 127584, 127589 }, - { 127744, 128724 }, - { 128736, 128748 }, - { 128752, 128761 }, - { 128768, 128883 }, - { 128896, 128984 }, - { 129024, 129035 }, - { 129040, 129095 }, - { 129104, 129113 }, - { 129120, 129159 }, - { 129168, 129197 }, - { 129280, 129291 }, - { 129296, 129342 }, - { 129344, 129392 }, - { 129395, 129398 }, - { 129402, 129402 }, - { 129404, 129442 }, - { 129456, 129465 }, - { 129472, 129474 }, - { 129488, 129535 }, - { 129632, 129645 }, - { 917505, 917505 }, - { 917536, 917631 }, +static const URange32 Phoenician_range32[] = { + { 67840, 67867 }, + { 67871, 67871 }, }; -static const URange16 Coptic_range16[] = { - { 994, 1007 }, - { 11392, 11507 }, - { 11513, 11519 }, +static const URange32 Psalter_Pahlavi_range32[] = { + { 68480, 68497 }, + { 68505, 68508 }, + { 68521, 68527 }, }; -static const URange32 Chakma_range32[] = { - { 69888, 69940 }, - { 69942, 69958 }, +static const URange16 Rejang_range16[] = { + { 43312, 43347 }, + { 43359, 43359 }, }; -static const URange16 Arabic_range16[] = { - { 1536, 1540 }, - { 1542, 1547 }, - { 1549, 1562 }, - { 1564, 1564 }, - { 1566, 1566 }, - { 1568, 1599 }, - { 1601, 1610 }, - { 1622, 1647 }, - { 1649, 1756 }, - { 1758, 1791 }, - { 1872, 1919 }, - { 2208, 2228 }, - { 2230, 2237 }, - { 2259, 2273 }, - { 2275, 2303 }, - { 64336, 64449 }, - { 64467, 64829 }, - { 64848, 64911 }, - { 64914, 64967 }, - { 65008, 65021 }, - { 65136, 65140 }, - { 65142, 65276 }, +static const URange16 Runic_range16[] = { + { 5792, 5866 }, + { 5870, 5880 }, }; -static const URange32 Arabic_range32[] = { - { 69216, 69246 }, - { 126464, 126467 }, - { 126469, 126495 }, - { 126497, 126498 }, - { 126500, 126500 }, - { 126503, 126503 }, - { 126505, 126514 }, - { 126516, 126519 }, - { 126521, 126521 }, - { 126523, 126523 }, - { 126530, 126530 }, - { 126535, 126535 }, - { 126537, 126537 }, - { 126539, 126539 }, - { 126541, 126543 }, - { 126545, 126546 }, - { 126548, 126548 }, - { 126551, 126551 }, - { 126553, 126553 }, - { 126555, 126555 }, - { 126557, 126557 }, - { 126559, 126559 }, - { 126561, 126562 }, - { 126564, 126564 }, - { 126567, 126570 }, - { 126572, 126578 }, - { 126580, 126583 }, - { 126585, 126588 }, - { 126590, 126590 }, - { 126592, 126601 }, - { 126603, 126619 }, - { 126625, 126627 }, - { 126629, 126633 }, - { 126635, 126651 }, - { 126704, 126705 }, +static const URange16 Samaritan_range16[] = { + { 2048, 2093 }, + { 2096, 2110 }, }; -static const URange16 Bamum_range16[] = { - { 42656, 42743 }, +static const URange16 Saurashtra_range16[] = { + { 43136, 43205 }, + { 43214, 43225 }, }; -static const URange32 Bamum_range32[] = { - { 92160, 92728 }, +static const URange32 Sharada_range32[] = { + { 70016, 70093 }, + { 70096, 70111 }, }; -static const URange16 Myanmar_range16[] = { - { 4096, 4255 }, - { 43488, 43518 }, - { 43616, 43647 }, +static const URange32 Shavian_range32[] = { + { 66640, 66687 }, }; static const URange32 Siddham_range32[] = { { 71040, 71093 }, { 71096, 71133 }, }; +static const URange32 SignWriting_range32[] = { + { 120832, 121483 }, + { 121499, 121503 }, + { 121505, 121519 }, +}; +static const URange16 Sinhala_range16[] = { + { 3458, 3459 }, + { 3461, 3478 }, + { 3482, 3505 }, + { 3507, 3515 }, + { 3517, 3517 }, + { 3520, 3526 }, + { 3530, 3530 }, + { 3535, 3540 }, + { 3542, 3542 }, + { 3544, 3551 }, + { 3558, 3567 }, + { 3570, 3572 }, +}; +static const URange32 Sinhala_range32[] = { + { 70113, 70132 }, +}; +static const URange32 Sogdian_range32[] = { + { 69424, 69465 }, +}; +static const URange32 Sora_Sompeng_range32[] = { + { 69840, 69864 }, + { 69872, 69881 }, +}; static const URange32 Soyombo_range32[] = { - { 72272, 72323 }, - { 72326, 72354 }, + { 72272, 72354 }, }; -static const URange32 Avestan_range32[] = { - { 68352, 68405 }, - { 68409, 68415 }, +static const URange16 Sundanese_range16[] = { + { 7040, 7103 }, + { 7360, 7367 }, }; -static const URange16 Hebrew_range16[] = { - { 1425, 1479 }, - { 1488, 1514 }, - { 1519, 1524 }, - { 64285, 64310 }, - { 64312, 64316 }, - { 64318, 64318 }, - { 64320, 64321 }, - { 64323, 64324 }, - { 64326, 64335 }, +static const URange16 Syloti_Nagri_range16[] = { + { 43008, 43051 }, }; -static const URange32 Psalter_Pahlavi_range32[] = { - { 68480, 68497 }, - { 68505, 68508 }, - { 68521, 68527 }, +static const URange16 Syriac_range16[] = { + { 1792, 1805 }, + { 1807, 1866 }, + { 1869, 1871 }, + { 2144, 2154 }, +}; +static const URange16 Tagalog_range16[] = { + { 5888, 5900 }, + { 5902, 5908 }, +}; +static const URange16 Tagbanwa_range16[] = { + { 5984, 5996 }, + { 5998, 6000 }, + { 6002, 6003 }, +}; +static const URange16 Tai_Le_range16[] = { + { 6480, 6509 }, + { 6512, 6516 }, +}; +static const URange16 Tai_Tham_range16[] = { + { 6688, 6750 }, + { 6752, 6780 }, + { 6783, 6793 }, + { 6800, 6809 }, + { 6816, 6829 }, +}; +static const URange16 Tai_Viet_range16[] = { + { 43648, 43714 }, + { 43739, 43743 }, }; static const URange32 Takri_range32[] = { - { 71296, 71351 }, + { 71296, 71352 }, { 71360, 71369 }, }; -// 3994 16-bit ranges, 1429 32-bit ranges +static const URange16 Tamil_range16[] = { + { 2946, 2947 }, + { 2949, 2954 }, + { 2958, 2960 }, + { 2962, 2965 }, + { 2969, 2970 }, + { 2972, 2972 }, + { 2974, 2975 }, + { 2979, 2980 }, + { 2984, 2986 }, + { 2990, 3001 }, + { 3006, 3010 }, + { 3014, 3016 }, + { 3018, 3021 }, + { 3024, 3024 }, + { 3031, 3031 }, + { 3046, 3066 }, +}; +static const URange32 Tamil_range32[] = { + { 73664, 73713 }, + { 73727, 73727 }, +}; +static const URange32 Tangut_range32[] = { + { 94176, 94176 }, + { 94208, 100343 }, + { 100352, 101106 }, +}; +static const URange16 Telugu_range16[] = { + { 3072, 3084 }, + { 3086, 3088 }, + { 3090, 3112 }, + { 3114, 3129 }, + { 3133, 3140 }, + { 3142, 3144 }, + { 3146, 3149 }, + { 3157, 3158 }, + { 3160, 3162 }, + { 3168, 3171 }, + { 3174, 3183 }, + { 3191, 3199 }, +}; +static const URange16 Thaana_range16[] = { + { 1920, 1969 }, +}; +static const URange16 Thai_range16[] = { + { 3585, 3642 }, + { 3648, 3675 }, +}; +static const URange16 Tibetan_range16[] = { + { 3840, 3911 }, + { 3913, 3948 }, + { 3953, 3991 }, + { 3993, 4028 }, + { 4030, 4044 }, + { 4046, 4052 }, + { 4057, 4058 }, +}; +static const URange16 Tifinagh_range16[] = { + { 11568, 11623 }, + { 11631, 11632 }, + { 11647, 11647 }, +}; +static const URange32 Tirhuta_range32[] = { + { 70784, 70855 }, + { 70864, 70873 }, +}; +static const URange32 Ugaritic_range32[] = { + { 66432, 66461 }, + { 66463, 66463 }, +}; +static const URange16 Vai_range16[] = { + { 42240, 42539 }, +}; +static const URange32 Wancho_range32[] = { + { 123584, 123641 }, + { 123647, 123647 }, +}; +static const URange32 Warang_Citi_range32[] = { + { 71840, 71922 }, + { 71935, 71935 }, +}; +static const URange16 Yi_range16[] = { + { 40960, 42124 }, + { 42128, 42182 }, +}; +static const URange32 Zanabazar_Square_range32[] = { + { 72192, 72263 }, +}; +// 3987 16-bit ranges, 1525 32-bit ranges const UGroup unicode_groups[] = { { "Adlam", +1, 0, 0, Adlam_range32, 3 }, { "Ahom", +1, 0, 0, Ahom_range32, 3 }, @@ -5883,17 +5982,17 @@ const UGroup unicode_groups[] = { { "Braille", +1, Braille_range16, 1, 0, 0 }, { "Buginese", +1, Buginese_range16, 2, 0, 0 }, { "Buhid", +1, Buhid_range16, 1, 0, 0 }, - { "C", +1, C_range16, 16, C_range32, 8 }, + { "C", +1, C_range16, 16, C_range32, 9 }, { "Canadian_Aboriginal", +1, Canadian_Aboriginal_range16, 2, 0, 0 }, { "Carian", +1, 0, 0, Carian_range32, 1 }, { "Caucasian_Albanian", +1, 0, 0, Caucasian_Albanian_range32, 2 }, { "Cc", +1, Cc_range16, 2, 0, 0 }, - { "Cf", +1, Cf_range16, 13, Cf_range32, 6 }, + { "Cf", +1, Cf_range16, 13, Cf_range32, 7 }, { "Chakma", +1, 0, 0, Chakma_range32, 2 }, { "Cham", +1, Cham_range16, 4, 0, 0 }, { "Cherokee", +1, Cherokee_range16, 3, 0, 0 }, { "Co", +1, Co_range16, 1, Co_range32, 2 }, - { "Common", +1, Common_range16, 90, Common_range32, 76 }, + { "Common", +1, Common_range16, 91, Common_range32, 81 }, { "Coptic", +1, Coptic_range16, 3, 0, 0 }, { "Cs", +1, Cs_range16, 1, 0, 0 }, { "Cuneiform", +1, 0, 0, Cuneiform_range32, 4 }, @@ -5903,8 +6002,9 @@ const UGroup unicode_groups[] = { { "Devanagari", +1, Devanagari_range16, 4, 0, 0 }, { "Dogra", +1, 0, 0, Dogra_range32, 1 }, { "Duployan", +1, 0, 0, Duployan_range32, 5 }, - { "Egyptian_Hieroglyphs", +1, 0, 0, Egyptian_Hieroglyphs_range32, 1 }, + { "Egyptian_Hieroglyphs", +1, 0, 0, Egyptian_Hieroglyphs_range32, 2 }, { "Elbasan", +1, 0, 0, Elbasan_range32, 1 }, + { "Elymaic", +1, 0, 0, Elymaic_range32, 1 }, { "Ethiopic", +1, Ethiopic_range16, 32, 0, 0 }, { "Georgian", +1, Georgian_range16, 10, 0, 0 }, { "Glagolitic", +1, Glagolitic_range16, 2, Glagolitic_range32, 5 }, @@ -5920,7 +6020,7 @@ const UGroup unicode_groups[] = { { "Hanunoo", +1, Hanunoo_range16, 1, 0, 0 }, { "Hatran", +1, 0, 0, Hatran_range32, 3 }, { "Hebrew", +1, Hebrew_range16, 9, 0, 0 }, - { "Hiragana", +1, Hiragana_range16, 2, Hiragana_range32, 2 }, + { "Hiragana", +1, Hiragana_range16, 2, Hiragana_range32, 3 }, { "Imperial_Aramaic", +1, 0, 0, Imperial_Aramaic_range32, 2 }, { "Inherited", +1, Inherited_range16, 20, Inherited_range32, 8 }, { "Inscriptional_Pahlavi", +1, 0, 0, Inscriptional_Pahlavi_range32, 2 }, @@ -5928,28 +6028,28 @@ const UGroup unicode_groups[] = { { "Javanese", +1, Javanese_range16, 3, 0, 0 }, { "Kaithi", +1, 0, 0, Kaithi_range32, 2 }, { "Kannada", +1, Kannada_range16, 13, 0, 0 }, - { "Katakana", +1, Katakana_range16, 7, Katakana_range32, 1 }, + { "Katakana", +1, Katakana_range16, 7, Katakana_range32, 2 }, { "Kayah_Li", +1, Kayah_Li_range16, 2, 0, 0 }, { "Kharoshthi", +1, 0, 0, Kharoshthi_range32, 8 }, { "Khmer", +1, Khmer_range16, 4, 0, 0 }, { "Khojki", +1, 0, 0, Khojki_range32, 2 }, { "Khudawadi", +1, 0, 0, Khudawadi_range32, 2 }, - { "L", +1, L_range16, 384, L_range32, 215 }, - { "Lao", +1, Lao_range16, 18, 0, 0 }, - { "Latin", +1, Latin_range16, 30, 0, 0 }, + { "L", +1, L_range16, 380, L_range32, 229 }, + { "Lao", +1, Lao_range16, 11, 0, 0 }, + { "Latin", +1, Latin_range16, 32, 0, 0 }, { "Lepcha", +1, Lepcha_range16, 3, 0, 0 }, { "Limbu", +1, Limbu_range16, 5, 0, 0 }, { "Linear_A", +1, 0, 0, Linear_A_range32, 3 }, { "Linear_B", +1, 0, 0, Linear_B_range32, 7 }, { "Lisu", +1, Lisu_range16, 1, 0, 0 }, - { "Ll", +1, Ll_range16, 604, Ll_range32, 34 }, - { "Lm", +1, Lm_range16, 54, Lm_range32, 3 }, - { "Lo", +1, Lo_range16, 295, Lo_range32, 175 }, + { "Ll", +1, Ll_range16, 608, Ll_range32, 34 }, + { "Lm", +1, Lm_range16, 54, Lm_range32, 6 }, + { "Lo", +1, Lo_range16, 290, Lo_range32, 186 }, { "Lt", +1, Lt_range16, 10, 0, 0 }, - { "Lu", +1, Lu_range16, 594, Lu_range32, 37 }, + { "Lu", +1, Lu_range16, 599, Lu_range32, 37 }, { "Lycian", +1, 0, 0, Lycian_range32, 1 }, { "Lydian", +1, 0, 0, Lydian_range32, 2 }, - { "M", +1, M_range16, 187, M_range32, 88 }, + { "M", +1, M_range16, 186, M_range32, 94 }, { "Mahajani", +1, 0, 0, Mahajani_range32, 1 }, { "Makasar", +1, 0, 0, Makasar_range32, 1 }, { "Malayalam", +1, Malayalam_range16, 8, 0, 0 }, @@ -5957,7 +6057,7 @@ const UGroup unicode_groups[] = { { "Manichaean", +1, 0, 0, Manichaean_range32, 2 }, { "Marchen", +1, 0, 0, Marchen_range32, 3 }, { "Masaram_Gondi", +1, 0, 0, Masaram_Gondi_range32, 7 }, - { "Mc", +1, Mc_range16, 110, Mc_range32, 56 }, + { "Mc", +1, Mc_range16, 109, Mc_range32, 59 }, { "Me", +1, Me_range16, 5, 0, 0 }, { "Medefaidrin", +1, 0, 0, Medefaidrin_range32, 1 }, { "Meetei_Mayek", +1, Meetei_Mayek_range16, 3, 0, 0 }, @@ -5965,21 +6065,23 @@ const UGroup unicode_groups[] = { { "Meroitic_Cursive", +1, 0, 0, Meroitic_Cursive_range32, 3 }, { "Meroitic_Hieroglyphs", +1, 0, 0, Meroitic_Hieroglyphs_range32, 1 }, { "Miao", +1, 0, 0, Miao_range32, 3 }, - { "Mn", +1, Mn_range16, 208, Mn_range32, 105 }, + { "Mn", +1, Mn_range16, 207, Mn_range32, 111 }, { "Modi", +1, 0, 0, Modi_range32, 2 }, { "Mongolian", +1, Mongolian_range16, 6, Mongolian_range32, 1 }, { "Mro", +1, 0, 0, Mro_range32, 3 }, { "Multani", +1, 0, 0, Multani_range32, 5 }, { "Myanmar", +1, Myanmar_range16, 3, 0, 0 }, - { "N", +1, N_range16, 67, N_range32, 58 }, + { "N", +1, N_range16, 67, N_range32, 63 }, { "Nabataean", +1, 0, 0, Nabataean_range32, 2 }, - { "Nd", +1, Nd_range16, 37, Nd_range32, 20 }, + { "Nandinagari", +1, 0, 0, Nandinagari_range32, 3 }, + { "Nd", +1, Nd_range16, 37, Nd_range32, 22 }, { "New_Tai_Lue", +1, New_Tai_Lue_range16, 4, 0, 0 }, { "Newa", +1, 0, 0, Newa_range32, 3 }, { "Nko", +1, Nko_range16, 2, 0, 0 }, { "Nl", +1, Nl_range16, 7, Nl_range32, 5 }, - { "No", +1, No_range16, 29, No_range32, 38 }, + { "No", +1, No_range16, 29, No_range32, 41 }, { "Nushu", +1, 0, 0, Nushu_range32, 2 }, + { "Nyiakeng_Puachue_Hmong", +1, 0, 0, Nyiakeng_Puachue_Hmong_range32, 4 }, { "Ogham", +1, Ogham_range16, 1, 0, 0 }, { "Ol_Chiki", +1, Ol_Chiki_range16, 1, 0, 0 }, { "Old_Hungarian", +1, 0, 0, Old_Hungarian_range32, 3 }, @@ -5993,7 +6095,7 @@ const UGroup unicode_groups[] = { { "Oriya", +1, Oriya_range16, 14, 0, 0 }, { "Osage", +1, 0, 0, Osage_range32, 2 }, { "Osmanya", +1, 0, 0, Osmanya_range32, 2 }, - { "P", +1, P_range16, 130, P_range32, 48 }, + { "P", +1, P_range16, 131, P_range32, 51 }, { "Pahawh_Hmong", +1, 0, 0, Pahawh_Hmong_range32, 5 }, { "Palmyrene", +1, 0, 0, Palmyrene_range32, 1 }, { "Pau_Cin_Hau", +1, 0, 0, Pau_Cin_Hau_range32, 1 }, @@ -6004,15 +6106,15 @@ const UGroup unicode_groups[] = { { "Phags_Pa", +1, Phags_Pa_range16, 1, 0, 0 }, { "Phoenician", +1, 0, 0, Phoenician_range32, 2 }, { "Pi", +1, Pi_range16, 11, 0, 0 }, - { "Po", +1, Po_range16, 127, Po_range32, 48 }, + { "Po", +1, Po_range16, 128, Po_range32, 51 }, { "Ps", +1, Ps_range16, 75, 0, 0 }, { "Psalter_Pahlavi", +1, 0, 0, Psalter_Pahlavi_range32, 3 }, { "Rejang", +1, Rejang_range16, 2, 0, 0 }, { "Runic", +1, Runic_range16, 2, 0, 0 }, - { "S", +1, S_range16, 147, S_range32, 73 }, + { "S", +1, S_range16, 146, S_range32, 80 }, { "Samaritan", +1, Samaritan_range16, 2, 0, 0 }, { "Saurashtra", +1, Saurashtra_range16, 2, 0, 0 }, - { "Sc", +1, Sc_range16, 18, Sc_range32, 1 }, + { "Sc", +1, Sc_range16, 18, Sc_range32, 3 }, { "Sharada", +1, 0, 0, Sharada_range32, 2 }, { "Shavian", +1, 0, 0, Shavian_range32, 1 }, { "Siddham", +1, 0, 0, Siddham_range32, 2 }, @@ -6020,10 +6122,10 @@ const UGroup unicode_groups[] = { { "Sinhala", +1, Sinhala_range16, 12, Sinhala_range32, 1 }, { "Sk", +1, Sk_range16, 28, Sk_range32, 1 }, { "Sm", +1, Sm_range16, 53, Sm_range32, 11 }, - { "So", +1, So_range16, 112, So_range32, 62 }, + { "So", +1, So_range16, 111, So_range32, 69 }, { "Sogdian", +1, 0, 0, Sogdian_range32, 1 }, { "Sora_Sompeng", +1, 0, 0, Sora_Sompeng_range32, 2 }, - { "Soyombo", +1, 0, 0, Soyombo_range32, 2 }, + { "Soyombo", +1, 0, 0, Soyombo_range32, 1 }, { "Sundanese", +1, Sundanese_range16, 2, 0, 0 }, { "Syloti_Nagri", +1, Syloti_Nagri_range16, 1, 0, 0 }, { "Syriac", +1, Syriac_range16, 4, 0, 0 }, @@ -6033,7 +6135,7 @@ const UGroup unicode_groups[] = { { "Tai_Tham", +1, Tai_Tham_range16, 5, 0, 0 }, { "Tai_Viet", +1, Tai_Viet_range16, 2, 0, 0 }, { "Takri", +1, 0, 0, Takri_range32, 2 }, - { "Tamil", +1, Tamil_range16, 16, 0, 0 }, + { "Tamil", +1, Tamil_range16, 16, Tamil_range32, 2 }, { "Tangut", +1, 0, 0, Tangut_range32, 3 }, { "Telugu", +1, Telugu_range16, 12, 0, 0 }, { "Thaana", +1, Thaana_range16, 1, 0, 0 }, @@ -6043,6 +6145,7 @@ const UGroup unicode_groups[] = { { "Tirhuta", +1, 0, 0, Tirhuta_range32, 2 }, { "Ugaritic", +1, 0, 0, Ugaritic_range32, 2 }, { "Vai", +1, Vai_range16, 1, 0, 0 }, + { "Wancho", +1, 0, 0, Wancho_range32, 2 }, { "Warang_Citi", +1, 0, 0, Warang_Citi_range32, 2 }, { "Yi", +1, Yi_range16, 2, 0, 0 }, { "Z", +1, Z_range16, 8, 0, 0 }, @@ -6051,7 +6154,7 @@ const UGroup unicode_groups[] = { { "Zp", +1, Zp_range16, 1, 0, 0 }, { "Zs", +1, Zs_range16, 7, 0, 0 }, }; -const int num_unicode_groups = 184; +const int num_unicode_groups = 188; } // namespace re2 diff --git a/util/pcre.cc b/util/pcre.cc index 93ac90c..5983c9f 100644 --- a/util/pcre.cc +++ b/util/pcre.cc @@ -734,9 +734,10 @@ bool PCRE::CheckRewriteString(const StringPiece& rewrite, } if (max_token > NumberOfCapturingGroups()) { - SStringPrintf(error, "Rewrite schema requests %d matches, " - "but the regexp only has %d parenthesized subexpressions.", - max_token, NumberOfCapturingGroups()); + *error = StringPrintf( + "Rewrite schema requests %d matches, but the regexp only has %d " + "parenthesized subexpressions.", + max_token, NumberOfCapturingGroups()); return false; } return true; diff --git a/util/strutil.cc b/util/strutil.cc index cc3b857..fb7e6b1 100644 --- a/util/strutil.cc +++ b/util/strutil.cc @@ -146,19 +146,4 @@ std::string StringPrintf(const char* format, ...) { return result; } -void SStringPrintf(std::string* dst, const char* format, ...) { - va_list ap; - va_start(ap, format); - dst->clear(); - StringAppendV(dst, format, ap); - va_end(ap); -} - -void StringAppendF(std::string* dst, const char* format, ...) { - va_list ap; - va_start(ap, format); - StringAppendV(dst, format, ap); - va_end(ap); -} - } // namespace re2 diff --git a/util/strutil.h b/util/strutil.h index b16981e..a69908a 100644 --- a/util/strutil.h +++ b/util/strutil.h @@ -15,8 +15,6 @@ namespace re2 { std::string CEscape(const StringPiece& src); void PrefixSuccessor(std::string* prefix); std::string StringPrintf(const char* format, ...); -void SStringPrintf(std::string* dst, const char* format, ...); -void StringAppendF(std::string* dst, const char* format, ...); } // namespace re2 diff --git a/util/util.h b/util/util.h index 3f75794..8f3e0d0 100644 --- a/util/util.h +++ b/util/util.h @@ -5,7 +5,7 @@ #ifndef UTIL_UTIL_H_ #define UTIL_UTIL_H_ -#define arraysize(array) (int)(sizeof(array)/sizeof((array)[0])) +#define arraysize(array) (sizeof(array)/sizeof((array)[0])) #ifndef ATTRIBUTE_NORETURN #if defined(__GNUC__) -- cgit v1.2.3