Our AST definition can include macro invocations, which can expand into all kinds of things. Macro invocations are expanded away during expansion time, and the rest of the compiler doesn't have to deal with them. However, we have no way of enforcing this.
This patch adds two protective mechanisms.
First, it adds a (quick) explicit check that ensures there are no macro invocations remaining in the AST after expansion. Second, it updates the visit and fold mechanisms so that by default, they will not traverse macro invocations. It's easy enough to add this, if desired (it's documented in the source, and examples appear, e.g. in the IdentFinder.
Along the way, I also consulted with @sfackler to refactor the macro export mechanism so that it stores macro text spans in a side table, rather than leaving them in the AST.
.SH OPTIONS
+.TP
+\fB\-\-crate-name NAME\fR
+Specify the name of the crate being built
.TP
\fB\-\-crate-type=[bin|lib|dylib|rlib|staticlib]\fR
Configure the flavor of rust crate that is generated (default `bin`)
TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
uuid serialize sync getopts collections num test time rand \
- url log regex graphviz core rlibc alloc debug rustrt
+ url log regex graphviz core rlibc alloc debug rustrt \
+ unicode
HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros
CRATES := $(TARGET_CRATES) $(HOST_CRATES)
TOOLS := compiletest rustdoc rustc
DEPS_core :=
DEPS_rlibc :=
+DEPS_unicode := core
DEPS_alloc := core libc native:jemalloc
DEPS_debug := std
DEPS_rustrt := alloc core libc collections native:rustrt_native
-DEPS_std := core libc rand alloc collections rustrt sync \
+DEPS_std := core libc rand alloc collections rustrt sync unicode \
native:rust_builtin native:backtrace
DEPS_graphviz := std
DEPS_green := std native:context_switch
DEPS_uuid := std serialize
DEPS_sync := core alloc rustrt collections
DEPS_getopts := std
-DEPS_collections := core alloc
+DEPS_collections := core alloc unicode
DEPS_fourcc := rustc syntax std
DEPS_hexfloat := rustc syntax std
DEPS_num := std
ONLY_RLIB_alloc := 1
ONLY_RLIB_rand := 1
ONLY_RLIB_collections := 1
+ONLY_RLIB_unicode := 1
################################################################################
# You should not need to edit below this line
$(Q)cd tmp/distcheck && tar -xzf ../../dist/$(PKG_NAME)-$(CFG_BUILD).tar.gz
$(Q)mkdir -p tmp/distcheck/tarbininstall
$(Q)sh tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix=tmp/distcheck/tarbininstall
- $(Q)tmp/distcheck/tarbininstall/bin/rustc --version
$(Q)sh tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix=tmp/distcheck/tarbininstall --uninstall
$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)
$(Q)rm -Rf tmp/distcheck/tarbininstall
MAYBE_DISABLE_VERIFY=
endif
-install: dist-install-dir-$(CFG_BUILD)-with-target-libs
- $(Q)sh tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)"
+install: dist-install-dir-$(CFG_BUILD)-with-target-libs | tmp/empty_dir
+ $(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)"
# Remove tmp files while we can because they may have been created under sudo
$(Q)rm -R tmp/dist
-uninstall: dist-install-dir-$(CFG_BUILD)-with-target-libs
- $(Q)sh tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --uninstall --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)"
+uninstall: dist-install-dir-$(CFG_BUILD)-with-target-libs | tmp/empty_dir
+ $(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --uninstall --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)"
# Remove tmp files while we can because they may have been created under sudo
$(Q)rm -R tmp/dist
+tmp/empty_dir:
+ mkdir -p $@
######################################################################
# Android remote installation
# $(4) is the crate name
define RUST_TARGET_STAGE_N
-# NOTE: after a stage0 snap this should be just EXTRA_FILENAME, not with a stage
-# or target bound
-EXTRA_FILENAME_$(1)_$(2) = -C extra-filename=-$$(CFG_FILENAME_EXTRA)
-ifeq ($(1),0)
-ifeq ($$(CFG_BUILD),$(2))
-EXTRA_FILENAME_$(1)_$(2) =
-endif
-endif
-
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): CFG_COMPILER_HOST_TRIPLE = $(2)
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
$$(CRATEFILE_$(4)) \
-L "$$(dir $$(LLVM_STDCPP_LOCATION_$(2)))" \
$$(RUSTFLAGS_$(4)) \
--out-dir $$(@D) \
- $$(EXTRA_FILENAME_$(1)_$(2)) \
+ -C extra-filename=-$$(CFG_FILENAME_EXTRA) \
$$<
@touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES,\
# The names of crates that must be tested
-# libcore tests are in a separate crate
+# libcore/libunicode tests are in a separate crate
DEPS_coretest :=
$(eval $(call RUST_CRATE,coretest))
-TEST_TARGET_CRATES = $(filter-out core,$(TARGET_CRATES)) coretest
+TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) coretest
TEST_DOC_CRATES = $(DOC_CRATES)
TEST_HOST_CRATES = $(HOST_CRATES)
TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::os;
use std::str;
use std::io::process::{ProcessExit, Command, Process, ProcessOutput};
use std::dynamic_lib::DynamicLibrary;
-fn target_env(lib_path: &str, aux_path: Option<&str>) -> Vec<(String, String)> {
+fn add_target_env(cmd: &mut Command, lib_path: &str, aux_path: Option<&str>) {
// Need to be sure to put both the lib_path and the aux path in the dylib
// search path for the child.
let mut path = DynamicLibrary::search_path();
}
path.insert(0, Path::new(lib_path));
- // Remove the previous dylib search path var
- let var = DynamicLibrary::envvar();
- let mut env: Vec<(String,String)> = os::env();
- match env.iter().position(|&(ref k, _)| k.as_slice() == var) {
- Some(i) => { env.remove(i); }
- None => {}
- }
-
// Add the new dylib search path var
+ let var = DynamicLibrary::envvar();
let newpath = DynamicLibrary::create_path(path.as_slice());
let newpath = str::from_utf8(newpath.as_slice()).unwrap().to_string();
- env.push((var.to_string(), newpath));
- return env;
+ cmd.env(var.to_string(), newpath);
}
pub struct Result {pub status: ProcessExit, pub out: String, pub err: String}
env: Vec<(String, String)> ,
input: Option<String>) -> Option<Result> {
- let env = env.clone().append(target_env(lib_path, aux_path).as_slice());
- match Command::new(prog).args(args).env(env.as_slice()).spawn() {
+ let mut cmd = Command::new(prog);
+ cmd.args(args);
+ add_target_env(&mut cmd, lib_path, aux_path);
+ for (key, val) in env.move_iter() {
+ cmd.env(key, val);
+ }
+
+ match cmd.spawn() {
Ok(mut process) => {
for input in input.iter() {
process.stdin.get_mut_ref().write(input.as_bytes()).unwrap();
env: Vec<(String, String)> ,
input: Option<String>) -> Option<Process> {
- let env = env.clone().append(target_env(lib_path, aux_path).as_slice());
- match Command::new(prog).args(args).env(env.as_slice()).spawn() {
+ let mut cmd = Command::new(prog);
+ cmd.args(args);
+ add_target_env(&mut cmd, lib_path, aux_path);
+ for (key, val) in env.move_iter() {
+ cmd.env(key, val);
+ }
+
+ match cmd.spawn() {
Ok(mut process) => {
for input in input.iter() {
process.stdin.get_mut_ref().write(input.as_bytes()).unwrap();
cmd.arg("./src/etc/lldb_batchmode.py")
.arg(test_executable)
.arg(debugger_script)
- .env([("PYTHONPATH", config.lldb_python_dir.clone().unwrap().as_slice())]);
+ .env_set_all([("PYTHONPATH", config.lldb_python_dir.clone().unwrap().as_slice())]);
let (status, out, err) = match cmd.spawn() {
Ok(process) => {
Rust projects, and so it is assumed that Rust projects will use Cargo from the
beginning.
-Programmers love car analogies, so I've got a good one for you to think about
-the relationship between `cargo` and `rustc`: `rustc` is like a car, and
-`cargo` is like a robotic driver. You can drive your car yourself, of course,
-but isn't it just easier to let a computer drive it for you?
-
-Anyway, Cargo manages three things: building your code, downloading the
-dependencies your code needs, and building the dependencies your code needs.
-At first, your program doesn't have any dependencies, so we'll only be using
-the first part of its functionality. Eventually, we'll add more. Since we
-started off by using Cargo, it'll be easy to add later.
+Cargo manages three things: building your code, downloading the dependencies
+your code needs, and building the dependencies your code needs. At first, your
+program doesn't have any dependencies, so we'll only be using the first part of
+its functionality. Eventually, we'll add more. Since we started off by using
+Cargo, it'll be easy to add later.
Let's convert Hello World to Cargo. The first thing we need to do to begin using Cargo
is to install Cargo. To do this, we need to build it from source. There are no binaries
CFG_LIBDIR_RELATIVE=bin
fi
+if [ "$CFG_OSTYPE" = "pc-mingw32" ] || [ "$CFG_OSTYPE" = "w64-mingw32" ]
+then
+ CFG_LD_PATH_VAR=PATH
+ CFG_OLD_LD_PATH_VAR=$PATH
+elif [ "$CFG_OSTYPE" = "Darwin" ]
+then
+ CFG_LD_PATH_VAR=DYLD_LIBRARY_PATH
+ CFG_OLD_LD_PATH_VAR=$DYLD_LIBRARY_PATH
+else
+ CFG_LD_PATH_VAR=LD_LIBRARY_PATH
+ CFG_OLD_LD_PATH_VAR=$LD_LIBRARY_PATH
+fi
+
flag uninstall "only uninstall from the installation prefix"
opt verify 1 "verify that the installed binaries run correctly"
valopt prefix "/usr/local" "set installation prefix"
if [ -z "${CFG_UNINSTALL}" ]
then
msg "verifying platform can run binaries"
+ export $CFG_LD_PATH_VAR="${CFG_SRC_DIR}/lib":$CFG_OLD_LD_PATH_VAR
"${CFG_SRC_DIR}/bin/rustc" --version > /dev/null
if [ $? -ne 0 ]
then
err "can't execute rustc binary on this platform"
fi
+ export $CFG_LD_PATH_VAR=$CFG_OLD_LD_PATH_VAR
fi
fi
# The manifest lists all files to install
done < "${CFG_SRC_DIR}/${CFG_LIBDIR_RELATIVE}/rustlib/manifest.in"
+# Run ldconfig to make dynamic libraries available to the linker
+if [ "$CFG_OSTYPE" = "Linux" ]
+ then
+ ldconfig
+ if [ $? -ne 0 ]
+ then
+ warn "failed to run ldconfig."
+ warn "this may happen when not installing as root and may be fine"
+ fi
+fi
+
# Sanity check: can we run the installed binaries?
+#
+# As with the verification above, make sure the right LD_LIBRARY_PATH-equivalent
+# is in place. Try first without this variable, and if that fails try again with
+# the variable. If the second time tries, print a hopefully helpful message to
+# add something to the appropriate environment variable.
if [ -z "${CFG_DISABLE_VERIFY}" ]
then
msg "verifying installed binaries are executable"
- "${CFG_PREFIX}/bin/rustc" --version > /dev/null
+ "${CFG_PREFIX}/bin/rustc" --version 2> /dev/null 1> /dev/null
if [ $? -ne 0 ]
then
- ERR="can't execute installed rustc binary. "
- ERR="${ERR}installation may be broken. "
- ERR="${ERR}if this is expected then rerun install.sh with \`--disable-verify\` "
- ERR="${ERR}or \`make install\` with \`--disable-verify-install\`"
- err "${ERR}"
+ export $CFG_LD_PATH_VAR="${CFG_PREFIX}/lib":$CFG_OLD_LD_PATH_VAR
+ "${CFG_PREFIX}/bin/rustc" --version > /dev/null
+ if [ $? -ne 0 ]
+ then
+ ERR="can't execute installed rustc binary. "
+ ERR="${ERR}installation may be broken. "
+ ERR="${ERR}if this is expected then rerun install.sh with \`--disable-verify\` "
+ ERR="${ERR}or \`make install\` with \`--disable-verify-install\`"
+ err "${ERR}"
+ else
+ echo
+ echo " Note: please ensure '${CFG_PREFIX}/lib' is added to ${CFG_LD_PATH_VAR}"
+ fi
fi
fi
-
echo
echo " Rust is ready to roll."
echo
+++ /dev/null
-#!/usr/bin/env python2
-
-# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-# file at the top-level directory of this distribution and at
-# http://rust-lang.org/COPYRIGHT.
-#
-# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-# option. This file may not be copied, modified, or distributed
-# except according to those terms.
-
-from __future__ import absolute_import, division, print_function
-import argparse
-from collections import defaultdict
-import csv
-import datetime
-import urllib2
-
-BASE_URL = 'http://www.unicode.org/Public/6.3.0/ucd/'
-DATA = 'UnicodeData.txt'
-SCRIPTS = 'Scripts.txt'
-
-# Mapping taken from Table 12 from:
-# http://www.unicode.org/reports/tr44/#General_Category_Values
-expanded_categories = {
- 'Lu': ['LC', 'L'], 'Ll': ['LC', 'L'], 'Lt': ['LC', 'L'],
- 'Lm': ['L'], 'Lo': ['L'],
- 'Mn': ['M'], 'Mc': ['M'], 'Me': ['M'],
- 'Nd': ['N'], 'Nl': ['N'], 'No': ['No'],
- 'Pc': ['P'], 'Pd': ['P'], 'Ps': ['P'], 'Pe': ['P'],
- 'Pi': ['P'], 'Pf': ['P'], 'Po': ['P'],
- 'Sm': ['S'], 'Sc': ['S'], 'Sk': ['S'], 'So': ['S'],
- 'Zs': ['Z'], 'Zl': ['Z'], 'Zp': ['Z'],
- 'Cc': ['C'], 'Cf': ['C'], 'Cs': ['C'], 'Co': ['C'], 'Cn': ['C'],
-}
-
-
-def as_4byte_uni(n):
- s = hex(n)[2:]
- return '\\U%s%s' % ('0' * (8 - len(s)), s)
-
-
-def expand_cat(c):
- return expanded_categories.get(c, []) + [c]
-
-
-def is_valid_unicode(n):
- return 0 <= n <= 0xD7FF or 0xE000 <= n <= 0x10FFFF
-
-
-def read_cats(f):
- assigned = defaultdict(list)
- for row in csv.reader(f, delimiter=';'):
- (hex, cats) = (int(row[0], 16), expand_cat(row[2]))
- if not is_valid_unicode(hex):
- continue
- for cat in cats:
- assigned[cat].append(hex)
- return assigned
-
-
-def read_scripts(f):
- assigned = defaultdict(list)
- for line in f:
- line = line.strip()
- if not line or line.startswith('#'):
- continue
- hexes, name = map(str.strip, line.split(';'))[:2]
- name = name[:name.index('#')].strip()
- if '..' not in hexes:
- hex = int(hexes, 16)
- if is_valid_unicode(hex):
- assigned[name].append(hex)
- else:
- hex1, hex2 = map(lambda s: int(s, 16), hexes.split('..'))
- for hex in xrange(hex1, hex2 + 1):
- if is_valid_unicode(hex):
- assigned[name].append(hex)
- return assigned
-
-
-def group(letters):
- letters = sorted(set(letters))
- grouped = []
- cur_start = letters.pop(0)
- cur_end = cur_start
- for letter in letters:
- assert letter > cur_end, \
- 'cur_end: %s, letter: %s' % (hex(cur_end), hex(letter))
-
- if letter == cur_end + 1:
- cur_end = letter
- else:
- grouped.append((cur_start, cur_end))
- cur_start, cur_end = letter, letter
- grouped.append((cur_start, cur_end))
- return grouped
-
-
-def ranges_to_rust(rs):
- rs = ("('%s', '%s')" % (as_4byte_uni(s), as_4byte_uni(e)) for s, e in rs)
- return ',\n '.join(rs)
-
-
-def groups_to_rust(groups):
- rust_groups = []
- for group_name in sorted(groups):
- rust_groups.append('("%s", &[\n %s\n ]),'
- % (group_name, ranges_to_rust(groups[group_name])))
- return '\n'.join(rust_groups)
-
-
-if __name__ == '__main__':
- parser = argparse.ArgumentParser(
- description='Generate Unicode character class tables.')
- aa = parser.add_argument
- aa('--local', action='store_true',
- help='When set, Scripts.txt and UnicodeData.txt will be read from '
- 'the CWD.')
- aa('--base-url', type=str, default=BASE_URL,
- help='The base URL to use for downloading Unicode data files.')
- args = parser.parse_args()
-
- if args.local:
- cats = read_cats(open(DATA))
- scripts = read_scripts(open(SCRIPTS))
- else:
- cats = read_cats(urllib2.urlopen(args.base_url + '/' + DATA))
- scripts = read_scripts(urllib2.urlopen(args.base_url + '/' + SCRIPTS))
-
- # Get Rust code for all Unicode general categories and scripts.
- combined = dict(cats, **scripts)
- unigroups = groups_to_rust({k: group(letters)
- for k, letters in combined.items()})
-
- # Now get Perl character classes that are Unicode friendly.
- perld = range(ord('0'), ord('9') + 1)
- dgroups = ranges_to_rust(group(perld + cats['Nd'][:]))
-
- perls = map(ord, ['\t', '\n', '\x0C', '\r', ' '])
- sgroups = ranges_to_rust(group(perls + cats['Z'][:]))
-
- low, up = (range(ord('a'), ord('z') + 1), range(ord('A'), ord('Z') + 1))
- perlw = [ord('_')] + perld + low + up
- wgroups = ranges_to_rust(group(perlw + cats['L'][:]))
-
- tpl = '''// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// DO NOT EDIT. Automatically generated by 'src/etc/regexp-unicode-tables'
-// on {date}.
-
-use parse::{{Class, NamedClasses}};
-
-pub static UNICODE_CLASSES: NamedClasses = &[
-
-{groups}
-
-];
-
-pub static PERLD: Class = &[
- {dgroups}
-];
-
-pub static PERLS: Class = &[
- {sgroups}
-];
-
-pub static PERLW: Class = &[
- {wgroups}
-];
-'''
- now = datetime.datetime.now()
- print(tpl.format(date=str(now), groups=unigroups,
- dgroups=dgroups, sgroups=sgroups, wgroups=wgroups))
# option. This file may not be copied, modified, or distributed
# except according to those terms.
-# This digests UnicodeData.txt and DerivedCoreProperties.txt and emits rust
-# code covering the core properties. Since this is a pretty rare event we
-# just store this out-of-line and check the unicode.rs file into git.
+# This script uses the following Unicode tables:
+# - DerivedCoreProperties.txt
+# - EastAsianWidth.txt
+# - PropList.txt
+# - Scripts.txt
+# - UnicodeData.txt
#
-# The emitted code is "the minimum we think is necessary for libstd", that
-# is, to support basic operations of the compiler and "most nontrivial rust
-# programs". It is not meant to be a complete implementation of unicode.
-# For that we recommend you use a proper binding to libicu.
+# Since this should not require frequent updates, we just store this
+# out-of-line and check the unicode.rs file into git.
import fileinput, re, os, sys, operator
+preamble = '''// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// NOTE: The following code was generated by "src/etc/unicode.py", do not edit directly
+
+#![allow(missing_doc, non_uppercase_statics, non_snake_case_functions)]
+'''
+
+# Mapping taken from Table 12 from:
+# http://www.unicode.org/reports/tr44/#General_Category_Values
+expanded_categories = {
+ 'Lu': ['LC', 'L'], 'Ll': ['LC', 'L'], 'Lt': ['LC', 'L'],
+ 'Lm': ['L'], 'Lo': ['L'],
+ 'Mn': ['M'], 'Mc': ['M'], 'Me': ['M'],
+ 'Nd': ['N'], 'Nl': ['N'], 'No': ['No'],
+ 'Pc': ['P'], 'Pd': ['P'], 'Ps': ['P'], 'Pe': ['P'],
+ 'Pi': ['P'], 'Pf': ['P'], 'Po': ['P'],
+ 'Sm': ['S'], 'Sc': ['S'], 'Sk': ['S'], 'So': ['S'],
+ 'Zs': ['Z'], 'Zl': ['Z'], 'Zp': ['Z'],
+ 'Cc': ['C'], 'Cf': ['C'], 'Cs': ['C'], 'Co': ['C'], 'Cn': ['C'],
+}
def fetch(f):
if not os.path.exists(f):
sys.stderr.write("cannot load %s" % f)
exit(1)
+def is_valid_unicode(n):
+ return 0 <= n <= 0xD7FF or 0xE000 <= n <= 0x10FFFF
def load_unicode_data(f):
fetch(f)
gencats = {}
upperlower = {}
lowerupper = {}
- combines = []
+ combines = {}
canon_decomp = {}
compat_decomp = {}
- curr_cat = ""
- curr_combine = ""
- c_lo = 0
- c_hi = 0
- com_lo = 0
- com_hi = 0
for line in fileinput.input(f):
fields = line.split(";")
code_org = code
code = int(code, 16)
+ if not is_valid_unicode(code):
+ continue
+
# generate char to char direct common and simple conversions
# uppercase to lowercase
if gencat == "Lu" and lowcase != "" and code_org != lowcase:
if gencat == "Ll" and upcase != "" and code_org != upcase:
lowerupper[code] = int(upcase, 16)
+ # store decomposition, if given
if decomp != "":
if decomp.startswith('<'):
seq = []
seq.append(int(i, 16))
canon_decomp[code] = seq
- if curr_cat == "":
- curr_cat = gencat
- c_lo = code
- c_hi = code
+ # place letter in categories as appropriate
+ for cat in [gencat] + expanded_categories.get(gencat, []):
+ if cat not in gencats:
+ gencats[cat] = []
+ gencats[cat].append(code)
- if curr_cat == gencat:
- c_hi = code
- else:
- if curr_cat not in gencats:
- gencats[curr_cat] = []
+ # record combining class, if any
+ if combine != "0":
+ if combine not in combines:
+ combines[combine] = []
+ combines[combine].append(code)
- gencats[curr_cat].append((c_lo, c_hi))
- curr_cat = gencat
- c_lo = code
- c_hi = code
+ gencats = group_cats(gencats)
+ combines = to_combines(group_cats(combines))
- if curr_combine == "":
- curr_combine = combine
- com_lo = code
- com_hi = code
+ return (canon_decomp, compat_decomp, gencats, combines, lowerupper, upperlower)
- if curr_combine == combine:
- com_hi = code
+def group_cats(cats):
+ cats_out = {}
+ for cat in cats:
+ cats_out[cat] = group_cat(cats[cat])
+ return cats_out
+
+def group_cat(cat):
+ cat_out = []
+ letters = sorted(set(cat))
+ cur_start = letters.pop(0)
+ cur_end = cur_start
+ for letter in letters:
+ assert letter > cur_end, \
+ "cur_end: %s, letter: %s" % (hex(cur_end), hex(letter))
+ if letter == cur_end + 1:
+ cur_end = letter
else:
- if curr_combine != "0":
- combines.append((com_lo, com_hi, curr_combine))
- curr_combine = combine
- com_lo = code
- com_hi = code
+ cat_out.append((cur_start, cur_end))
+ cur_start = cur_end = letter
+ cat_out.append((cur_start, cur_end))
+ return cat_out
+
+def ungroup_cat(cat):
+ cat_out = []
+ for (lo, hi) in cat:
+ while lo <= hi:
+ cat_out.append(lo)
+ lo += 1
+ return cat_out
+
+def to_combines(combs):
+ combs_out = []
+ for comb in combs:
+ for (lo, hi) in combs[comb]:
+ combs_out.append((lo, hi, comb))
+ combs_out.sort(key=lambda comb: comb[0])
+ return combs_out
- return (canon_decomp, compat_decomp, gencats, combines, lowerupper, upperlower)
+def format_table_content(f, content, indent):
+ line = " "*indent
+ first = True
+ for chunk in content.split(","):
+ if len(line) + len(chunk) < 98:
+ if first:
+ line += chunk
+ else:
+ line += ", " + chunk
+ first = False
+ else:
+ f.write(line + ",\n")
+ line = " "*indent + chunk
+ f.write(line)
def load_properties(f, interestingprops):
fetch(f)
prop = m.group(3)
else:
continue
- if prop not in interestingprops:
+ if interestingprops and prop not in interestingprops:
continue
d_lo = int(d_lo, 16)
d_hi = int(d_hi, 16)
props[prop].append((d_lo, d_hi))
return props
+# load all widths of want_widths, except those in except_cats
+def load_east_asian_width(want_widths, except_cats):
+ f = "EastAsianWidth.txt"
+ fetch(f)
+ widths = {}
+ re1 = re.compile("^([0-9A-F]+);(\w+) +# (\w+)")
+ re2 = re.compile("^([0-9A-F]+)\.\.([0-9A-F]+);(\w+) +# (\w+)")
+
+ for line in fileinput.input(f):
+ width = None
+ d_lo = 0
+ d_hi = 0
+ cat = None
+ m = re1.match(line)
+ if m:
+ d_lo = m.group(1)
+ d_hi = m.group(1)
+ width = m.group(2)
+ cat = m.group(3)
+ else:
+ m = re2.match(line)
+ if m:
+ d_lo = m.group(1)
+ d_hi = m.group(2)
+ width = m.group(3)
+ cat = m.group(4)
+ else:
+ continue
+ if cat in except_cats or width not in want_widths:
+ continue
+ d_lo = int(d_lo, 16)
+ d_hi = int(d_hi, 16)
+ if width not in widths:
+ widths[width] = []
+ widths[width].append((d_lo, d_hi))
+ return widths
+
def escape_char(c):
if c <= 0xff:
return "'\\x%2.2x'" % c
return "'\\u%4.4x'" % c
return "'\\U%8.8x'" % c
-def ch_prefix(ix):
- if ix == 0:
- return " "
- if ix % 2 == 0:
- return ",\n "
- else:
- return ", "
-
def emit_bsearch_range_table(f):
f.write("""
fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
- use cmp::{Equal, Less, Greater};
- use slice::ImmutableVector;
- use option::None;
+ use core::cmp::{Equal, Less, Greater};
+ use core::slice::ImmutableVector;
+ use core::option::None;
r.bsearch(|&(lo,hi)| {
if lo <= c && c <= hi { Equal }
else if hi < c { Less }
else { Greater }
}) != None
}\n
-""");
+""")
+
+def emit_table(f, name, t_data, t_type = "&'static [(char, char)]", is_pub=True,
+ pfun=lambda x: "(%s,%s)" % (escape_char(x[0]), escape_char(x[1]))):
+ pub_string = ""
+ if is_pub:
+ pub_string = "pub "
+ f.write(" %sstatic %s: %s = &[\n" % (pub_string, name, t_type))
+ data = ""
+ first = True
+ for dat in t_data:
+ if not first:
+ data += ","
+ first = False
+ data += pfun(dat)
+ format_table_content(f, data, 8)
+ f.write("\n ];\n\n")
-def emit_property_module(f, mod, tbl):
+def emit_property_module(f, mod, tbl, emit_fn):
f.write("pub mod %s {\n" % mod)
keys = tbl.keys()
keys.sort()
-
for cat in keys:
- if cat not in ["Nd", "Nl", "No", "Cc",
- "XID_Start", "XID_Continue", "Alphabetic",
- "Lowercase", "Uppercase", "White_Space"]:
- continue
- f.write(" static %s_table : &'static [(char,char)] = &[\n" % cat)
- ix = 0
- for pair in tbl[cat]:
- f.write(ch_prefix(ix))
- f.write("(%s, %s)" % (escape_char(pair[0]), escape_char(pair[1])))
- ix += 1
- f.write("\n ];\n\n")
-
- f.write(" pub fn %s(c: char) -> bool {\n" % cat)
- f.write(" super::bsearch_range_table(c, %s_table)\n" % cat)
- f.write(" }\n\n")
+ emit_table(f, "%s_table" % cat, tbl[cat])
+ if cat in emit_fn:
+ f.write(" pub fn %s(c: char) -> bool {\n" % cat)
+ f.write(" super::bsearch_range_table(c, %s_table)\n" % cat)
+ f.write(" }\n\n")
f.write("}\n\n")
+def emit_regex_module(f, cats, w_data):
+ f.write("pub mod regex {\n")
+ regex_class = "&'static [(char, char)]"
+ class_table = "&'static [(&'static str, %s)]" % regex_class
+
+ emit_table(f, "UNICODE_CLASSES", cats, class_table,
+ pfun=lambda x: "(\"%s\",super::%s::%s_table)" % (x[0], x[1], x[0]))
+
+ f.write(" pub static PERLD: %s = super::general_category::Nd_table;\n\n"
+ % regex_class)
+ f.write(" pub static PERLS: %s = super::property::White_Space_table;\n\n"
+ % regex_class)
+
+ emit_table(f, "PERLW", w_data, regex_class)
+
+ f.write("}\n\n")
def emit_conversions_module(f, lowerupper, upperlower):
f.write("pub mod conversions {")
f.write("""
- use cmp::{Equal, Less, Greater};
- use slice::ImmutableVector;
- use tuple::Tuple2;
- use option::{Option, Some, None};
+ use core::cmp::{Equal, Less, Greater};
+ use core::slice::ImmutableVector;
+ use core::tuple::Tuple2;
+ use core::option::{Option, Some, None};
pub fn to_lower(c: char) -> char {
match bsearch_case_table(c, LuLl_table) {
})
}
-""");
- emit_caseconversion_table(f, "LuLl", upperlower)
- emit_caseconversion_table(f, "LlLu", lowerupper)
- f.write("}\n")
-
-def emit_caseconversion_table(f, name, table):
- f.write(" static %s_table : &'static [(char, char)] = &[\n" % name)
- sorted_table = sorted(table.iteritems(), key=operator.itemgetter(0))
- ix = 0
- for key, value in sorted_table:
- f.write(ch_prefix(ix))
- f.write("(%s, %s)" % (escape_char(key), escape_char(value)))
- ix += 1
- f.write("\n ];\n\n")
-
-def format_table_content(f, content, indent):
- line = " "*indent
- first = True
- for chunk in content.split(","):
- if len(line) + len(chunk) < 98:
- if first:
- line += chunk
- else:
- line += ", " + chunk
- first = False
- else:
- f.write(line + ",\n")
- line = " "*indent + chunk
- f.write(line)
-
-def emit_core_norm_module(f, canon, compat):
- canon_keys = canon.keys()
- canon_keys.sort()
+""")
+ emit_table(f, "LuLl_table",
+ sorted(upperlower.iteritems(), key=operator.itemgetter(0)), is_pub=False)
+ emit_table(f, "LlLu_table",
+ sorted(lowerupper.iteritems(), key=operator.itemgetter(0)), is_pub=False)
+ f.write("}\n\n")
- compat_keys = compat.keys()
- compat_keys.sort()
- f.write("pub mod normalization {\n");
- f.write(" use option::Option;\n");
- f.write(" use option::{Some, None};\n");
- f.write(" use slice::ImmutableVector;\n");
+def emit_charwidth_module(f, width_table):
+ f.write("pub mod charwidth {\n")
+ f.write(" use core::option::{Option, Some, None};\n")
+ f.write(" use core::slice::ImmutableVector;\n")
f.write("""
- fn bsearch_table(c: char, r: &'static [(char, &'static [char])]) -> Option<&'static [char]> {
- use cmp::{Equal, Less, Greater};
- match r.bsearch(|&(val, _)| {
- if c == val { Equal }
- else if val < c { Less }
+ fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
+ use core::cmp::{Equal, Less, Greater};
+ match r.bsearch(|&(lo, hi, _, _)| {
+ if lo <= c && c <= hi { Equal }
+ else if hi < c { Less }
else { Greater }
}) {
Some(idx) => {
- let (_, result) = r[idx];
- Some(result)
+ let (_, _, r_ncjk, r_cjk) = r[idx];
+ if is_cjk { r_cjk } else { r_ncjk }
}
- None => None
+ None => 1
}
- }\n\n
+ }
""")
- f.write(" // Canonical decompositions\n")
- f.write(" static canonical_table : &'static [(char, &'static [char])] = &[\n")
- data = ""
- first = True
- for char in canon_keys:
- if not first:
- data += ","
- first = False
- data += "(%s,&[" % escape_char(char)
- first2 = True
- for d in canon[char]:
- if not first2:
- data += ","
- first2 = False
- data += escape_char(d)
- data += "])"
- format_table_content(f, data, 8)
- f.write("\n ];\n\n")
-
- f.write(" // Compatibility decompositions\n")
- f.write(" static compatibility_table : &'static [(char, &'static [char])] = &[\n")
- data = ""
- first = True
- for char in compat_keys:
- if not first:
- data += ","
- first = False
- data += "(%s,&[" % escape_char(char)
- first2 = True
- for d in compat[char]:
- if not first2:
- data += ","
- first2 = False
- data += escape_char(d)
- data += "])"
- format_table_content(f, data, 8)
- f.write("\n ];\n\n")
-
f.write("""
- pub fn decompose_canonical(c: char, i: |char|) { d(c, i, false); }
-
- pub fn decompose_compatible(c: char, i: |char|) { d(c, i, true); }
-
- fn d(c: char, i: |char|, k: bool) {
- use iter::Iterator;
-
- // 7-bit ASCII never decomposes
- if c <= '\\x7f' { i(c); return; }
-
- // Perform decomposition for Hangul
- if (c as u32) >= S_BASE && (c as u32) < (S_BASE + S_COUNT) {
- decompose_hangul(c, i);
- return;
+ pub fn width(c: char, is_cjk: bool) -> Option<uint> {
+ match c as uint {
+ _c @ 0 => Some(0), // null is zero width
+ cu if cu < 0x20 => None, // control sequences have no width
+ cu if cu < 0x7F => Some(1), // ASCII
+ cu if cu < 0xA0 => None, // more control sequences
+ _ => Some(bsearch_range_value_table(c, is_cjk, charwidth_table) as uint)
}
+ }
- // First check the canonical decompositions
- match bsearch_table(c, canonical_table) {
- Some(canon) => {
- for x in canon.iter() {
- d(*x, |b| i(b), k);
- }
- return;
- }
- None => ()
- }
+""")
- // Bottom out if we're not doing compat.
- if !k { i(c); return; }
+ f.write(" // character width table. Based on Markus Kuhn's free wcwidth() implementation,\n")
+ f.write(" // http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c\n")
+ emit_table(f, "charwidth_table", width_table, "&'static [(char, char, u8, u8)]", is_pub=False,
+ pfun=lambda x: "(%s,%s,%s,%s)" % (escape_char(x[0]), escape_char(x[1]), x[2], x[3]))
+ f.write("}\n")
- // Then check the compatibility decompositions
- match bsearch_table(c, compatibility_table) {
- Some(compat) => {
- for x in compat.iter() {
- d(*x, |b| i(b), k);
- }
- return;
- }
- None => ()
- }
+def emit_norm_module(f, canon, compat, combine):
+ canon_keys = canon.keys()
+ canon_keys.sort()
- // Finally bottom out.
- i(c);
- }
+ compat_keys = compat.keys()
+ compat_keys.sort()
- // Constants from Unicode 6.2.0 Section 3.12 Conjoining Jamo Behavior
- static S_BASE: u32 = 0xAC00;
- static L_BASE: u32 = 0x1100;
- static V_BASE: u32 = 0x1161;
- static T_BASE: u32 = 0x11A7;
- static L_COUNT: u32 = 19;
- static V_COUNT: u32 = 21;
- static T_COUNT: u32 = 28;
- static N_COUNT: u32 = (V_COUNT * T_COUNT);
- static S_COUNT: u32 = (L_COUNT * N_COUNT);
-
- // Decompose a precomposed Hangul syllable
- fn decompose_hangul(s: char, f: |char|) {
- use cast::transmute;
-
- let si = s as u32 - S_BASE;
-
- let li = si / N_COUNT;
- unsafe {
- f(transmute(L_BASE + li));
-
- let vi = (si % N_COUNT) / T_COUNT;
- f(transmute(V_BASE + vi));
-
- let ti = si % T_COUNT;
- if ti > 0 {
- f(transmute(T_BASE + ti));
- }
- }
- }
-}
+ f.write("pub mod normalization {\n")
+
+ def mkdata_fun(table):
+ def f(char):
+ data = "(%s,&[" % escape_char(char)
+ first = True
+ for d in table[char]:
+ if not first:
+ data += ","
+ first = False
+ data += escape_char(d)
+ data += "])"
+ return data
+ return f
-""")
+ f.write(" // Canonical decompositions\n")
+ emit_table(f, "canonical_table", canon_keys, "&'static [(char, &'static [char])]",
+ pfun=mkdata_fun(canon))
-def emit_std_norm_module(f, combine):
- f.write("pub mod normalization {\n");
- f.write(" use option::{Some, None};\n");
- f.write(" use slice::ImmutableVector;\n");
+ f.write(" // Compatibility decompositions\n")
+ emit_table(f, "compatibility_table", compat_keys, "&'static [(char, &'static [char])]",
+ pfun=mkdata_fun(compat))
f.write("""
fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
- use cmp::{Equal, Less, Greater};
+ use core::option::{Some, None};
+ use core::cmp::{Equal, Less, Greater};
+ use core::slice::ImmutableVector;
match r.bsearch(|&(lo, hi, _)| {
if lo <= c && c <= hi { Equal }
else if hi < c { Less }
}
None => 0
}
- }\n\n
+ }\n
""")
- f.write(" static combining_class_table : &'static [(char, char, u8)] = &[\n")
- ix = 0
- for pair in combine:
- f.write(ch_prefix(ix))
- f.write("(%s, %s, %s)" % (escape_char(pair[0]), escape_char(pair[1]), pair[2]))
- ix += 1
- f.write("\n ];\n\n")
+ emit_table(f, "combining_class_table", combine, "&'static [(char, char, u8)]", is_pub=False,
+ pfun=lambda x: "(%s,%s,%s)" % (escape_char(x[0]), escape_char(x[1]), x[2]))
f.write(" pub fn canonical_combining_class(c: char) -> u8 {\n"
+ " bsearch_range_value_table(c, combining_class_table)\n"
+ " }\n")
- f.write("}\n")
-
-
-preamble = '''// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-// NOTE: The following code was generated by "src/etc/unicode.py", do not edit directly
-
-#![allow(missing_doc, non_uppercase_statics)]
+ f.write("""
+}
-'''
+""")
-(canon_decomp, compat_decomp, gencats,
- combines, lowerupper, upperlower) = load_unicode_data("UnicodeData.txt")
+def remove_from_wtable(wtable, val):
+ wtable_out = []
+ while wtable:
+ if wtable[0][1] < val:
+ wtable_out.append(wtable.pop(0))
+ elif wtable[0][0] > val:
+ break
+ else:
+ (wt_lo, wt_hi, width, width_cjk) = wtable.pop(0)
+ if wt_lo == wt_hi == val:
+ continue
+ elif wt_lo == val:
+ wtable_out.append((wt_lo+1, wt_hi, width, width_cjk))
+ elif wt_hi == val:
+ wtable_out.append((wt_lo, wt_hi-1, width, width_cjk))
+ else:
+ wtable_out.append((wt_lo, val-1, width, width_cjk))
+ wtable_out.append((val+1, wt_hi, width, width_cjk))
+ if wtable:
+ wtable_out.extend(wtable)
+ return wtable_out
+
+def optimize_width_table(wtable):
+ wtable_out = []
+ w_this = wtable.pop(0)
+ while wtable:
+ if w_this[1] == wtable[0][0] - 1 and w_this[2:3] == wtable[0][2:3]:
+ w_tmp = wtable.pop(0)
+ w_this = (w_this[0], w_tmp[1], w_tmp[2], w_tmp[3])
+ else:
+ wtable_out.append(w_this)
+ w_this = wtable.pop(0)
+ wtable_out.append(w_this)
+ return wtable_out
-def gen_core_unicode():
- r = "core_unicode.rs"
+if __name__ == "__main__":
+ r = "unicode.rs"
if os.path.exists(r):
- os.remove(r);
+ os.remove(r)
with open(r, "w") as rf:
- # Preamble
+ # write the file's preamble
rf.write(preamble)
- emit_bsearch_range_table(rf);
- emit_property_module(rf, "general_category", gencats)
-
- emit_core_norm_module(rf, canon_decomp, compat_decomp)
+ # download and parse all the data
+ (canon_decomp, compat_decomp, gencats, combines,
+ lowerupper, upperlower) = load_unicode_data("UnicodeData.txt")
+ want_derived = ["XID_Start", "XID_Continue", "Alphabetic", "Lowercase", "Uppercase"]
+ other_derived = ["Default_Ignorable_Code_Point"]
+ derived = load_properties("DerivedCoreProperties.txt", want_derived + other_derived)
+ scripts = load_properties("Scripts.txt", [])
+ props = load_properties("PropList.txt",
+ ["White_Space", "Join_Control", "Noncharacter_Code_Point"])
+
+ # bsearch_range_table is used in all the property modules below
+ emit_bsearch_range_table(rf)
+
+ # all of these categories will also be available as \p{} in libregex
+ allcats = []
+ for (name, cat, pfuns) in ("general_category", gencats, ["N", "Cc"]), \
+ ("derived_property", derived, want_derived), \
+ ("script", scripts, []), \
+ ("property", props, ["White_Space"]):
+ emit_property_module(rf, name, cat, pfuns)
+ allcats.extend(map(lambda x: (x, name), cat))
+ allcats.sort(key=lambda c: c[0])
+
+ # the \w regex corresponds to Alphabetic + Mark + Decimal_Number +
+ # Connector_Punctuation + Join-Control according to UTS#18
+ # http://www.unicode.org/reports/tr18/#Compatibility_Properties
+ perl_words = []
+ for cat in derived["Alphabetic"], gencats["M"], gencats["Nd"], \
+ gencats["Pc"], props["Join_Control"]:
+ perl_words.extend(ungroup_cat(cat))
+ perl_words = group_cat(perl_words)
+
+ # emit lookup tables for \p{}, along with \d, \w, and \s for libregex
+ emit_regex_module(rf, allcats, perl_words)
+
+ # normalizations and conversions module
+ emit_norm_module(rf, canon_decomp, compat_decomp, combines)
+ emit_conversions_module(rf, lowerupper, upperlower)
- derived = load_properties("DerivedCoreProperties.txt",
- ["XID_Start", "XID_Continue", "Alphabetic", "Lowercase", "Uppercase"])
+ # character width module
+ width_table = []
+ for zwcat in ["Me", "Mn", "Cf"]:
+ width_table.extend(map(lambda (lo, hi): (lo, hi, 0, 0), gencats[zwcat]))
+ width_table.append((4448, 4607, 0, 0))
- emit_property_module(rf, "derived_property", derived)
+ # get widths, except those that are explicitly marked zero-width above
+ ea_widths = load_east_asian_width(["W", "F", "A"], ["Me", "Mn", "Cf"])
+ # these are doublewidth
+ for dwcat in ["W", "F"]:
+ width_table.extend(map(lambda (lo, hi): (lo, hi, 2, 2), ea_widths[dwcat]))
+ width_table.extend(map(lambda (lo, hi): (lo, hi, 1, 2), ea_widths["A"]))
- props = load_properties("PropList.txt", ["White_Space"])
- emit_property_module(rf, "property", props)
- emit_conversions_module(rf, lowerupper, upperlower)
+ width_table.sort(key=lambda w: w[0])
-def gen_std_unicode():
- r = "std_unicode.rs"
- if os.path.exists(r):
- os.remove(r);
- with open(r, "w") as rf:
- # Preamble
- rf.write(preamble)
- emit_std_norm_module(rf, combines)
+ # soft hyphen is not zero width in preformatted text; it's used to indicate
+ # a hyphen inserted to facilitate a linebreak.
+ width_table = remove_from_wtable(width_table, 173)
-gen_core_unicode()
-gen_std_unicode()
+ # optimize the width table by collapsing adjacent entities when possible
+ width_table = optimize_width_table(width_table)
+ emit_charwidth_module(rf, width_table)
-c'[Compile and assemble, but do not link]'
--cfg'[Configure the compilation environment]'
--crate-id'[Output the crate id and exit]'
- --crate-file-name'[Output the file(s) that would be written if compilation continued and exit]'
- --crate-name'[Output the crate name and exit]'
- --dep-info'[Output dependency info to <filename> after compiling]'
+ --crate-file-name'[deprecated in favor of --print-file-name]'
+ --crate-name'[Specify the name of the crate being built]'
--crate-type'[Specify the type of crate to crate]'
+ --debuginfo'[Emit DWARF debug info to the objects created: 0 = no debug info, 1 = line-tables only (for stacktraces and breakpoints), 2 = full debug info with variable and type information (same as -g)]'
+ --dep-info'[Output dependency info to <filename> after compiling]'
+ -g'[Equivalent to --debuginfo=2]'
{-h,--help}'[Display this message]'
-L'[Add a directory to the library search path]'
--linker'[Program to use for linking instead of the default.]'
--parse-only'[Parse only; do not compile, assemble, or link]'
--passes'[Comma or space separated list of pass names to use]'
--pretty'[Pretty-print the input instead of compiling]'
+ --print-crate-name'[Output the crate name and exit]'
+ --print-file-name'[Output the file(s) that would be written if compilation continued and exit]'
--save-temps'[Write intermediate files (.bc, .opt.bc, .o) in addition to normal output]'
--sysroot'[Override the system root]'
--test'[Build a test harness]'
//! by libc malloc/free. The `libc_heap` module is defined to be wired up to
//! the system malloc/free.
-#![crate_id = "alloc#0.11.0"] // NOTE: remove after a stage0 snap
#![crate_name = "alloc"]
#![experimental]
#![license = "MIT/ASL2"]
#![no_std]
#![feature(lang_items, phase, unsafe_destructor)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#[phase(plugin, link)]
extern crate core;
//! arena but can only hold objects of a single type, and Arena, which is a
//! more complex, slower Arena which can hold objects of any type.
-#![crate_id = "arena#0.11.0"]
#![crate_name = "arena"]
#![experimental]
#![crate_type = "rlib"]
#![feature(unsafe_destructor)]
#![allow(missing_doc)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
use std::cell::{Cell, RefCell};
use std::cmp;
use core::default::Default;
use core::fmt;
use core::iter::Take;
+use core::ops::Index;
use core::slice;
use core::uint;
use std::hash;
use {Collection, Mutable, Set, MutableSet};
use vec::Vec;
-#[cfg(not(stage0))]
-use core::ops::Index;
-#[cfg(not(stage0))]
static TRUE: bool = true;
-
-#[cfg(not(stage0))]
static FALSE: bool = false;
#[deriving(Clone)]
nbits: uint
}
-#[cfg(not(stage0))]
impl Index<uint,bool> for Bitv {
#[inline]
fn index<'a>(&'a self, i: &uint) -> &'a bool {
fn test_small_clear() {
let mut b = Bitv::with_capacity(14, true);
b.clear();
- BitvSet::from_bitv(b).iter().advance(|i| {
- fail!("found 1 at {:?}", i)
- });
+ assert!(b.none());
}
#[test]
fn test_big_clear() {
let mut b = Bitv::with_capacity(140, true);
b.clear();
- BitvSet::from_bitv(b).iter().advance(|i| {
- fail!("found 1 at {:?}", i)
- });
+ assert!(b.none());
}
#[test]
assert!(b.insert(5));
assert!(b.insert(3));
- let mut i = 0;
let expected = [3, 5, 11, 77];
- a.intersection(&b).advance(|x| {
- assert_eq!(x, expected[i]);
- i += 1;
- true
- });
- assert_eq!(i, expected.len());
+ let actual = a.intersection(&b).collect::<Vec<uint>>();
+ assert_eq!(actual.as_slice(), expected.as_slice());
}
#[test]
assert!(b.insert(3));
assert!(b.insert(200));
- let mut i = 0;
let expected = [1, 5, 500];
- a.difference(&b).advance(|x| {
- assert_eq!(x, expected[i]);
- i += 1;
- true
- });
- assert_eq!(i, expected.len());
+ let actual = a.difference(&b).collect::<Vec<uint>>();
+ assert_eq!(actual.as_slice(), expected.as_slice());
}
#[test]
assert!(b.insert(14));
assert!(b.insert(220));
- let mut i = 0;
let expected = [1, 5, 11, 14, 220];
- a.symmetric_difference(&b).advance(|x| {
- assert_eq!(x, expected[i]);
- i += 1;
- true
- });
- assert_eq!(i, expected.len());
+ let actual = a.symmetric_difference(&b).collect::<Vec<uint>>();
+ assert_eq!(actual.as_slice(), expected.as_slice());
}
#[test]
assert!(b.insert(13));
assert!(b.insert(19));
- let mut i = 0;
let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160];
- a.union(&b).advance(|x| {
- assert_eq!(x, expected[i]);
- i += 1;
- true
- });
- assert_eq!(i, expected.len());
+ let actual = a.union(&b).collect::<Vec<uint>>();
+ assert_eq!(actual.as_slice(), expected.as_slice());
}
#[test]
mod tests {
use test::Bencher;
use std::prelude::*;
- use std::num::ToStrRadix;
+ use std::fmt;
use str::Str;
use string::String;
fn to_hex_str(r: &[u8, ..8]) -> String {
let mut s = String::new();
for b in r.iter() {
- s.push_str((*b as uint).to_str_radix(16u).as_slice());
+ s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice());
}
s
}
let r = result_bytes(h);
let mut s = String::new();
for b in r.iter() {
- s.push_str((*b as uint).to_str_radix(16u).as_slice());
+ s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice());
}
s
}
* Collection types.
*/
-#![crate_id = "collections#0.11.0"] // NOTE: remove after stage0
#![crate_name = "collections"]
#![experimental]
#![crate_type = "rlib"]
#![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
#![feature(unsafe_destructor)]
#![no_std]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#[phase(plugin, link)] extern crate core;
+extern crate unicode;
extern crate alloc;
#[cfg(test)] extern crate native;
pub mod vec;
pub mod hash;
-// Internal unicode fiddly bits for the str module
-mod unicode;
-
mod deque;
/// A trait to represent mutable containers
use core::prelude::*;
-use core::char;
use core::default::Default;
use core::fmt;
use core::cmp;
use Collection;
use hash;
use string::String;
+use unicode;
use vec::Vec;
pub use core::str::{from_utf8, CharEq, Chars, CharOffsets};
pub use core::str::{Bytes, CharSplits};
-pub use core::str::{CharSplitsN, Words, AnyLines, MatchIndices, StrSplits};
+pub use core::str::{CharSplitsN, AnyLines, MatchIndices, StrSplits};
pub use core::str::{eq_slice, is_utf8, is_utf16, Utf16Items};
pub use core::str::{Utf16Item, ScalarValue, LoneSurrogate, utf16_items};
pub use core::str::{truncate_utf16_at_nul, utf8_char_width, CharRange};
pub use core::str::{Str, StrSlice};
+pub use unicode::{Words, UnicodeStrSlice};
/*
Section: Creating a string
impl<'a> Iterator<char> for Decompositions<'a> {
#[inline]
fn next(&mut self) -> Option<char> {
- use unicode::normalization::canonical_combining_class;
+ use unicode::canonical_combining_class;
match self.buffer.as_slice().head() {
Some(&(c, 0)) => {
}
let decomposer = match self.kind {
- Canonical => char::decompose_canonical,
- Compatible => char::decompose_compatible
+ Canonical => unicode::char::decompose_canonical,
+ Compatible => unicode::char::decompose_compatible
};
if !self.sorted {
use string::String;
use vec::Vec;
+ use unicode::UnicodeChar;
+
#[test]
fn test_eq_slice() {
assert!((eq_slice("foobar".slice(0, 3), "foo")));
}
impl<K: Ord, V> Map<K, V> for TreeMap<K, V> {
+ // See comments on tree_find_with
+ #[inline]
fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
- let mut current = &self.root;
- loop {
- match *current {
- Some(ref r) => {
- match key.cmp(&r.key) {
- Less => current = &r.left,
- Greater => current = &r.right,
- Equal => return Some(&r.value)
- }
- }
- None => return None
- }
- }
+ tree_find_with(&self.root, |k2| key.cmp(k2))
}
}
impl<K: Ord, V> MutableMap<K, V> for TreeMap<K, V> {
+ // See comments on def_tree_find_mut_with
#[inline]
fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V> {
- let mut current = &mut self.root;
- loop {
- let temp = current; // hack to appease borrowck
- match *temp {
- Some(ref mut r) => {
- match key.cmp(&r.key) {
- Less => current = &mut r.left,
- Greater => current = &mut r.right,
- Equal => return Some(&mut r.value)
- }
- }
- None => return None
- }
- }
+ tree_find_mut_with(&mut self.root, |x| key.cmp(x))
}
fn swap(&mut self, key: K, value: V) -> Option<V> {
}
}
+impl<K, V> TreeMap<K, V> {
+ /// Return the value for which f(key) returns Equal. f is invoked
+ /// with current key and helps to navigate the tree
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// use std::ascii::StrAsciiExt;
+ ///
+ /// let mut t = collections::treemap::TreeMap::new();
+ /// t.insert("Content-Type", "application/xml");
+ /// t.insert("User-Agent", "Curl-Rust/0.1");
+ ///
+ /// let ua_key = "user-agent";
+ /// let ua = t.find_with(|&k| {
+ /// ua_key.cmp(&k.to_ascii_lower().as_slice())
+ /// });
+ ///
+ /// assert_eq!(*ua.unwrap(), "Curl-Rust/0.1");
+ /// ```
+ #[inline]
+ pub fn find_with<'a>(&'a self, f:|&K| -> Ordering) -> Option<&'a V> {
+ tree_find_with(&self.root, f)
+ }
+
+ /// Return the value for which f(key) returns Equal. f is invoked
+ /// with current key and helps to navigate the tree
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// let mut t = collections::treemap::TreeMap::new();
+ /// t.insert("Content-Type", "application/xml");
+ /// t.insert("User-Agent", "Curl-Rust/0.1");
+ ///
+ /// let new_ua = "Safari/156.0";
+ /// match t.find_mut_with(|k| "User-Agent".cmp(k)) {
+ /// Some(x) => *x = new_ua,
+ /// None => fail!(),
+ /// }
+ ///
+ /// assert_eq!(t.find(&"User-Agent"), Some(&new_ua));
+ /// ```
+ #[inline]
+ pub fn find_mut_with<'a>(&'a mut self, f:|&K| -> Ordering) -> Option<&'a mut V> {
+ tree_find_mut_with(&mut self.root, f)
+ }
+}
+
// range iterators.
macro_rules! bound_setup {
}
}
+// Next 2 functions have the same conventions
+//
+// The only difference is that non-mutable version uses loop instead
+// of recursion (performance considerations)
+// It seems to be impossible to avoid recursion with mutability
+//
+// So convention is that comparator is gets at input current key
+// and returns search_key cmp cur_key (i.e. search_key.cmp(cur_key))
+fn tree_find_with<'r, K, V>(node: &'r Option<Box<TreeNode<K, V>>>,
+ f: |&K| -> Ordering) -> Option<&'r V> {
+ let mut current: &'r Option<Box<TreeNode<K, V>>> = node;
+ loop {
+ match *current {
+ Some(ref r) => {
+ match f(&r.key) {
+ Less => current = &r.left,
+ Greater => current = &r.right,
+ Equal => return Some(&r.value)
+ }
+ }
+ None => return None
+ }
+ }
+}
+
+// See comments above tree_find_with
+fn tree_find_mut_with<'r, K, V>(node: &'r mut Option<Box<TreeNode<K, V>>>,
+ f: |&K| -> Ordering) -> Option<&'r mut V> {
+
+ let mut current = node;
+ loop {
+ let temp = current; // hack to appease borrowck
+ match *temp {
+ Some(ref mut r) => {
+ match f(&r.key) {
+ Less => current = &mut r.left,
+ Greater => current = &mut r.right,
+ Equal => return Some(&mut r.value)
+ }
+ }
+ None => return None
+ }
+ }
+}
+
fn insert<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
key: K, value: V) -> Option<V> {
match *node {
assert_eq!(m.find(&2), None);
}
+ #[test]
+ fn find_with_empty() {
+ let m: TreeMap<&'static str,int> = TreeMap::new();
+ assert!(m.find_with(|k| "test".cmp(k)) == None);
+ }
+
+ #[test]
+ fn find_with_not_found() {
+ let mut m = TreeMap::new();
+ assert!(m.insert("test1", 2i));
+ assert!(m.insert("test2", 3i));
+ assert!(m.insert("test3", 3i));
+ assert_eq!(m.find_with(|k| "test4".cmp(k)), None);
+ }
+
+ #[test]
+ fn find_with_found() {
+ let mut m = TreeMap::new();
+ assert!(m.insert("test1", 2i));
+ assert!(m.insert("test2", 3i));
+ assert!(m.insert("test3", 4i));
+ assert_eq!(m.find_with(|k| "test2".cmp(k)), Some(&3i));
+ }
+
#[test]
fn test_find_mut() {
let mut m = TreeMap::new();
assert_eq!(m.find(&5), Some(&new));
}
+ #[test]
+ fn test_find_with_mut() {
+ let mut m = TreeMap::new();
+ assert!(m.insert("t1", 12i));
+ assert!(m.insert("t2", 8));
+ assert!(m.insert("t5", 14));
+ let new = 100;
+ match m.find_mut_with(|k| "t5".cmp(k)) {
+ None => fail!(), Some(x) => *x = new
+ }
+ assert_eq!(m.find_with(|k| "t5".cmp(k)), Some(&new));
+ }
+
#[test]
fn insert_replace() {
let mut m = TreeMap::new();
#[test]
fn test_intersection() {
fn check_intersection(a: &[int], b: &[int], expected: &[int]) {
- check(a, b, expected, |x, y, f| x.intersection(y).advance(f))
+ check(a, b, expected, |x, y, f| x.intersection(y).all(f))
}
check_intersection([], [], []);
#[test]
fn test_difference() {
fn check_difference(a: &[int], b: &[int], expected: &[int]) {
- check(a, b, expected, |x, y, f| x.difference(y).advance(f))
+ check(a, b, expected, |x, y, f| x.difference(y).all(f))
}
check_difference([], [], []);
fn test_symmetric_difference() {
fn check_symmetric_difference(a: &[int], b: &[int],
expected: &[int]) {
- check(a, b, expected, |x, y, f| x.symmetric_difference(y).advance(f))
+ check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
}
check_symmetric_difference([], [], []);
fn test_union() {
fn check_union(a: &[int], b: &[int],
expected: &[int]) {
- check(a, b, expected, |x, y, f| x.union(y).advance(f))
+ check(a, b, expected, |x, y, f| x.union(y).all(f))
}
check_union([], [], []);
+++ /dev/null
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// NOTE: The following code was generated by "src/etc/unicode.py", do not edit directly
-
-#![allow(missing_doc, non_uppercase_statics)]
-
-pub mod normalization {
- use core::prelude::*;
-
- fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
- match r.bsearch(|&(lo, hi, _)| {
- if lo <= c && c <= hi { Equal }
- else if hi < c { Less }
- else { Greater }
- }) {
- Some(idx) => {
- let (_, _, result) = r[idx];
- result
- }
- None => 0
- }
- }
-
-
- static combining_class_table : &'static [(char, char, u8)] = &[
- ('\u0300', '\u0314', 230), ('\u0315', '\u0315', 232),
- ('\u0316', '\u0319', 220), ('\u031a', '\u031a', 232),
- ('\u031b', '\u031b', 216), ('\u031c', '\u0320', 220),
- ('\u0321', '\u0322', 202), ('\u0323', '\u0326', 220),
- ('\u0327', '\u0328', 202), ('\u0329', '\u0333', 220),
- ('\u0334', '\u0338', 1), ('\u0339', '\u033c', 220),
- ('\u033d', '\u0344', 230), ('\u0345', '\u0345', 240),
- ('\u0346', '\u0346', 230), ('\u0347', '\u0349', 220),
- ('\u034a', '\u034c', 230), ('\u034d', '\u034e', 220),
- ('\u0350', '\u0352', 230), ('\u0353', '\u0356', 220),
- ('\u0357', '\u0357', 230), ('\u0358', '\u0358', 232),
- ('\u0359', '\u035a', 220), ('\u035b', '\u035b', 230),
- ('\u035c', '\u035c', 233), ('\u035d', '\u035e', 234),
- ('\u035f', '\u035f', 233), ('\u0360', '\u0361', 234),
- ('\u0362', '\u0362', 233), ('\u0363', '\u036f', 230),
- ('\u0483', '\u0487', 230), ('\u0591', '\u0591', 220),
- ('\u0592', '\u0595', 230), ('\u0596', '\u0596', 220),
- ('\u0597', '\u0599', 230), ('\u059a', '\u059a', 222),
- ('\u059b', '\u059b', 220), ('\u059c', '\u05a1', 230),
- ('\u05a2', '\u05a7', 220), ('\u05a8', '\u05a9', 230),
- ('\u05aa', '\u05aa', 220), ('\u05ab', '\u05ac', 230),
- ('\u05ad', '\u05ad', 222), ('\u05ae', '\u05ae', 228),
- ('\u05af', '\u05af', 230), ('\u05b0', '\u05b0', 10),
- ('\u05b1', '\u05b1', 11), ('\u05b2', '\u05b2', 12),
- ('\u05b3', '\u05b3', 13), ('\u05b4', '\u05b4', 14),
- ('\u05b5', '\u05b5', 15), ('\u05b6', '\u05b6', 16),
- ('\u05b7', '\u05b7', 17), ('\u05b8', '\u05b8', 18),
- ('\u05b9', '\u05ba', 19), ('\u05bb', '\u05bb', 20),
- ('\u05bc', '\u05bc', 21), ('\u05bd', '\u05bd', 22),
- ('\u05bf', '\u05bf', 23), ('\u05c1', '\u05c1', 24),
- ('\u05c2', '\u05c2', 25), ('\u05c4', '\u05c4', 230),
- ('\u05c5', '\u05c5', 220), ('\u05c7', '\u05c7', 18),
- ('\u0610', '\u0617', 230), ('\u0618', '\u0618', 30),
- ('\u0619', '\u0619', 31), ('\u061a', '\u061a', 32),
- ('\u064b', '\u064b', 27), ('\u064c', '\u064c', 28),
- ('\u064d', '\u064d', 29), ('\u064e', '\u064e', 30),
- ('\u064f', '\u064f', 31), ('\u0650', '\u0650', 32),
- ('\u0651', '\u0651', 33), ('\u0652', '\u0652', 34),
- ('\u0653', '\u0654', 230), ('\u0655', '\u0656', 220),
- ('\u0657', '\u065b', 230), ('\u065c', '\u065c', 220),
- ('\u065d', '\u065e', 230), ('\u065f', '\u065f', 220),
- ('\u0670', '\u0670', 35), ('\u06d6', '\u06dc', 230),
- ('\u06df', '\u06e2', 230), ('\u06e3', '\u06e3', 220),
- ('\u06e4', '\u06e4', 230), ('\u06e7', '\u06e8', 230),
- ('\u06ea', '\u06ea', 220), ('\u06eb', '\u06ec', 230),
- ('\u06ed', '\u06ed', 220), ('\u0711', '\u0711', 36),
- ('\u0730', '\u0730', 230), ('\u0731', '\u0731', 220),
- ('\u0732', '\u0733', 230), ('\u0734', '\u0734', 220),
- ('\u0735', '\u0736', 230), ('\u0737', '\u0739', 220),
- ('\u073a', '\u073a', 230), ('\u073b', '\u073c', 220),
- ('\u073d', '\u073d', 230), ('\u073e', '\u073e', 220),
- ('\u073f', '\u0741', 230), ('\u0742', '\u0742', 220),
- ('\u0743', '\u0743', 230), ('\u0744', '\u0744', 220),
- ('\u0745', '\u0745', 230), ('\u0746', '\u0746', 220),
- ('\u0747', '\u0747', 230), ('\u0748', '\u0748', 220),
- ('\u0749', '\u074a', 230), ('\u07eb', '\u07f1', 230),
- ('\u07f2', '\u07f2', 220), ('\u07f3', '\u07f3', 230),
- ('\u0816', '\u0819', 230), ('\u081b', '\u0823', 230),
- ('\u0825', '\u0827', 230), ('\u0829', '\u082d', 230),
- ('\u0859', '\u085b', 220), ('\u08e4', '\u08e5', 230),
- ('\u08e6', '\u08e6', 220), ('\u08e7', '\u08e8', 230),
- ('\u08e9', '\u08e9', 220), ('\u08ea', '\u08ec', 230),
- ('\u08ed', '\u08ef', 220), ('\u08f0', '\u08f0', 27),
- ('\u08f1', '\u08f1', 28), ('\u08f2', '\u08f2', 29),
- ('\u08f3', '\u08f5', 230), ('\u08f6', '\u08f6', 220),
- ('\u08f7', '\u08f8', 230), ('\u08f9', '\u08fa', 220),
- ('\u08fb', '\u08fe', 230), ('\u093c', '\u093c', 7),
- ('\u094d', '\u094d', 9), ('\u0951', '\u0951', 230),
- ('\u0952', '\u0952', 220), ('\u0953', '\u0954', 230),
- ('\u09bc', '\u09bc', 7), ('\u09cd', '\u09cd', 9),
- ('\u0a3c', '\u0a3c', 7), ('\u0a4d', '\u0a4d', 9),
- ('\u0abc', '\u0abc', 7), ('\u0acd', '\u0acd', 9),
- ('\u0b3c', '\u0b3c', 7), ('\u0b4d', '\u0b4d', 9),
- ('\u0bcd', '\u0bcd', 9), ('\u0c4d', '\u0c4d', 9),
- ('\u0c55', '\u0c55', 84), ('\u0c56', '\u0c56', 91),
- ('\u0cbc', '\u0cbc', 7), ('\u0ccd', '\u0ccd', 9),
- ('\u0d4d', '\u0d4d', 9), ('\u0dca', '\u0dca', 9),
- ('\u0e38', '\u0e39', 103), ('\u0e3a', '\u0e3a', 9),
- ('\u0e48', '\u0e4b', 107), ('\u0eb8', '\u0eb9', 118),
- ('\u0ec8', '\u0ecb', 122), ('\u0f18', '\u0f19', 220),
- ('\u0f35', '\u0f35', 220), ('\u0f37', '\u0f37', 220),
- ('\u0f39', '\u0f39', 216), ('\u0f71', '\u0f71', 129),
- ('\u0f72', '\u0f72', 130), ('\u0f74', '\u0f74', 132),
- ('\u0f7a', '\u0f7d', 130), ('\u0f80', '\u0f80', 130),
- ('\u0f82', '\u0f83', 230), ('\u0f84', '\u0f84', 9),
- ('\u0f86', '\u0f87', 230), ('\u0fc6', '\u0fc6', 220),
- ('\u1037', '\u1037', 7), ('\u1039', '\u103a', 9),
- ('\u108d', '\u108d', 220), ('\u135d', '\u135f', 230),
- ('\u1714', '\u1714', 9), ('\u1734', '\u1734', 9),
- ('\u17d2', '\u17d2', 9), ('\u17dd', '\u17dd', 230),
- ('\u18a9', '\u18a9', 228), ('\u1939', '\u1939', 222),
- ('\u193a', '\u193a', 230), ('\u193b', '\u193b', 220),
- ('\u1a17', '\u1a17', 230), ('\u1a18', '\u1a18', 220),
- ('\u1a60', '\u1a60', 9), ('\u1a75', '\u1a7c', 230),
- ('\u1a7f', '\u1a7f', 220), ('\u1b34', '\u1b34', 7),
- ('\u1b44', '\u1b44', 9), ('\u1b6b', '\u1b6b', 230),
- ('\u1b6c', '\u1b6c', 220), ('\u1b6d', '\u1b73', 230),
- ('\u1baa', '\u1bab', 9), ('\u1be6', '\u1be6', 7),
- ('\u1bf2', '\u1bf3', 9), ('\u1c37', '\u1c37', 7),
- ('\u1cd0', '\u1cd2', 230), ('\u1cd4', '\u1cd4', 1),
- ('\u1cd5', '\u1cd9', 220), ('\u1cda', '\u1cdb', 230),
- ('\u1cdc', '\u1cdf', 220), ('\u1ce0', '\u1ce0', 230),
- ('\u1ce2', '\u1ce8', 1), ('\u1ced', '\u1ced', 220),
- ('\u1cf4', '\u1cf4', 230), ('\u1dc0', '\u1dc1', 230),
- ('\u1dc2', '\u1dc2', 220), ('\u1dc3', '\u1dc9', 230),
- ('\u1dca', '\u1dca', 220), ('\u1dcb', '\u1dcc', 230),
- ('\u1dcd', '\u1dcd', 234), ('\u1dce', '\u1dce', 214),
- ('\u1dcf', '\u1dcf', 220), ('\u1dd0', '\u1dd0', 202),
- ('\u1dd1', '\u1de6', 230), ('\u1dfc', '\u1dfc', 233),
- ('\u1dfd', '\u1dfd', 220), ('\u1dfe', '\u1dfe', 230),
- ('\u1dff', '\u1dff', 220), ('\u20d0', '\u20d1', 230),
- ('\u20d2', '\u20d3', 1), ('\u20d4', '\u20d7', 230),
- ('\u20d8', '\u20da', 1), ('\u20db', '\u20dc', 230),
- ('\u20e1', '\u20e1', 230), ('\u20e5', '\u20e6', 1),
- ('\u20e7', '\u20e7', 230), ('\u20e8', '\u20e8', 220),
- ('\u20e9', '\u20e9', 230), ('\u20ea', '\u20eb', 1),
- ('\u20ec', '\u20ef', 220), ('\u20f0', '\u20f0', 230),
- ('\u2cef', '\u2cf1', 230), ('\u2d7f', '\u2d7f', 9),
- ('\u2de0', '\u2dff', 230), ('\u302a', '\u302a', 218),
- ('\u302b', '\u302b', 228), ('\u302c', '\u302c', 232),
- ('\u302d', '\u302d', 222), ('\u302e', '\u302f', 224),
- ('\u3099', '\u309a', 8), ('\ua66f', '\ua66f', 230),
- ('\ua674', '\ua67d', 230), ('\ua69f', '\ua69f', 230),
- ('\ua6f0', '\ua6f1', 230), ('\ua806', '\ua806', 9),
- ('\ua8c4', '\ua8c4', 9), ('\ua8e0', '\ua8f1', 230),
- ('\ua92b', '\ua92d', 220), ('\ua953', '\ua953', 9),
- ('\ua9b3', '\ua9b3', 7), ('\ua9c0', '\ua9c0', 9),
- ('\uaab0', '\uaab0', 230), ('\uaab2', '\uaab3', 230),
- ('\uaab4', '\uaab4', 220), ('\uaab7', '\uaab8', 230),
- ('\uaabe', '\uaabf', 230), ('\uaac1', '\uaac1', 230),
- ('\uaaf6', '\uaaf6', 9), ('\uabed', '\uabed', 9),
- ('\ufb1e', '\ufb1e', 26), ('\ufe20', '\ufe26', 230),
- ('\U000101fd', '\U000101fd', 220), ('\U00010a0d', '\U00010a0d', 220),
- ('\U00010a0f', '\U00010a0f', 230), ('\U00010a38', '\U00010a38', 230),
- ('\U00010a39', '\U00010a39', 1), ('\U00010a3a', '\U00010a3a', 220),
- ('\U00010a3f', '\U00010a3f', 9), ('\U00011046', '\U00011046', 9),
- ('\U000110b9', '\U000110b9', 9), ('\U000110ba', '\U000110ba', 7),
- ('\U00011100', '\U00011102', 230), ('\U00011133', '\U00011134', 9),
- ('\U000111c0', '\U000111c0', 9), ('\U000116b6', '\U000116b6', 9),
- ('\U000116b7', '\U000116b7', 7), ('\U0001d165', '\U0001d166', 216),
- ('\U0001d167', '\U0001d169', 1), ('\U0001d16d', '\U0001d16d', 226),
- ('\U0001d16e', '\U0001d172', 216), ('\U0001d17b', '\U0001d182', 220),
- ('\U0001d185', '\U0001d189', 230), ('\U0001d18a', '\U0001d18b', 220),
- ('\U0001d1aa', '\U0001d1ad', 230), ('\U0001d242', '\U0001d244', 230)
- ];
-
- pub fn canonical_combining_class(c: char) -> u8 {
- bsearch_range_value_table(c, combining_class_table)
- }
-}
/// ```
#[inline]
pub fn from_slice(values: &[T]) -> Vec<T> {
- values.iter().map(|x| x.clone()).collect()
+ let mut vector = Vec::new();
+ vector.push_all(values);
+ vector
}
/// Constructs a `Vec` with copies of a value.
/// ```
#[inline]
pub fn push_all(&mut self, other: &[T]) {
- self.extend(other.iter().map(|e| e.clone()));
+ self.reserve_additional(other.len());
+
+ for i in range(0, other.len()) {
+ let len = self.len();
+
+ // Unsafe code so this can be optimised to a memcpy (or something similarly
+ // fast) when T is Copy. LLVM is easily confused, so any extra operations
+ // during the loop can prevent this optimisation.
+ unsafe {
+ ptr::write(
+ self.as_mut_slice().unsafe_mut_ref(len),
+ other.unsafe_ref(i).clone());
+ self.set_len(len + 1);
+ }
+ }
}
/// Grows the `Vec` in-place.
#[unstable]
impl<T:Clone> Clone for Vec<T> {
fn clone(&self) -> Vec<T> {
- let len = self.len;
- let mut vector = Vec::with_capacity(len);
- // Unsafe code so this can be optimised to a memcpy (or something
- // similarly fast) when T is Copy. LLVM is easily confused, so any
- // extra operations during the loop can prevent this optimisation
- {
- let this_slice = self.as_slice();
- while vector.len < len {
- unsafe {
- let len = vector.len;
- ptr::write(
- vector.as_mut_slice().unsafe_mut_ref(len),
- this_slice.unsafe_ref(len).clone());
- }
- vector.len += 1;
- }
- }
- vector
+ Vec::from_slice(self.as_slice())
}
fn clone_from(&mut self, other: &Vec<T>) {
// self.len <= other.len due to the truncate above, so the
// slice here is always in-bounds.
- let len = self.len();
- self.extend(other.slice_from(len).iter().map(|x| x.clone()));
+ let slice = other.slice_from(self.len());
+ self.push_all(slice);
}
}
}
}
-
#[cfg(test)]
mod tests {
extern crate test;
#[bench]
fn bench_new(b: &mut Bencher) {
b.iter(|| {
- let v: Vec<int> = Vec::new();
+ let v: Vec<uint> = Vec::new();
+ assert_eq!(v.len(), 0);
assert_eq!(v.capacity(), 0);
- assert!(v.as_slice() == []);
})
}
- #[bench]
- fn bench_with_capacity_0(b: &mut Bencher) {
+ fn do_bench_with_capacity(b: &mut Bencher, src_len: uint) {
+ b.bytes = src_len as u64;
+
b.iter(|| {
- let v: Vec<int> = Vec::with_capacity(0);
- assert_eq!(v.capacity(), 0);
- assert!(v.as_slice() == []);
+ let v: Vec<uint> = Vec::with_capacity(src_len);
+ assert_eq!(v.len(), 0);
+ assert_eq!(v.capacity(), src_len);
})
}
+ #[bench]
+ fn bench_with_capacity_0000(b: &mut Bencher) {
+ do_bench_with_capacity(b, 0)
+ }
#[bench]
- fn bench_with_capacity_5(b: &mut Bencher) {
- b.iter(|| {
- let v: Vec<int> = Vec::with_capacity(5);
- assert_eq!(v.capacity(), 5);
- assert!(v.as_slice() == []);
- })
+ fn bench_with_capacity_0010(b: &mut Bencher) {
+ do_bench_with_capacity(b, 10)
}
#[bench]
- fn bench_with_capacity_100(b: &mut Bencher) {
+ fn bench_with_capacity_0100(b: &mut Bencher) {
+ do_bench_with_capacity(b, 100)
+ }
+
+ #[bench]
+ fn bench_with_capacity_1000(b: &mut Bencher) {
+ do_bench_with_capacity(b, 1000)
+ }
+
+ fn do_bench_from_fn(b: &mut Bencher, src_len: uint) {
+ b.bytes = src_len as u64;
+
b.iter(|| {
- let v: Vec<int> = Vec::with_capacity(100);
- assert_eq!(v.capacity(), 100);
- assert!(v.as_slice() == []);
+ let dst = Vec::from_fn(src_len, |i| i);
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
})
}
#[bench]
- fn bench_from_fn_0(b: &mut Bencher) {
+ fn bench_from_fn_0000(b: &mut Bencher) {
+ do_bench_from_fn(b, 0)
+ }
+
+ #[bench]
+ fn bench_from_fn_0010(b: &mut Bencher) {
+ do_bench_from_fn(b, 10)
+ }
+
+ #[bench]
+ fn bench_from_fn_0100(b: &mut Bencher) {
+ do_bench_from_fn(b, 100)
+ }
+
+ #[bench]
+ fn bench_from_fn_1000(b: &mut Bencher) {
+ do_bench_from_fn(b, 1000)
+ }
+
+ fn do_bench_from_elem(b: &mut Bencher, src_len: uint) {
+ b.bytes = src_len as u64;
+
b.iter(|| {
- let v: Vec<int> = Vec::from_fn(0, |_| 5);
- assert!(v.as_slice() == []);
+ let dst: Vec<uint> = Vec::from_elem(src_len, 5);
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().all(|x| *x == 5));
})
}
#[bench]
- fn bench_from_fn_5(b: &mut Bencher) {
+ fn bench_from_elem_0000(b: &mut Bencher) {
+ do_bench_from_elem(b, 0)
+ }
+
+ #[bench]
+ fn bench_from_elem_0010(b: &mut Bencher) {
+ do_bench_from_elem(b, 10)
+ }
+
+ #[bench]
+ fn bench_from_elem_0100(b: &mut Bencher) {
+ do_bench_from_elem(b, 100)
+ }
+
+ #[bench]
+ fn bench_from_elem_1000(b: &mut Bencher) {
+ do_bench_from_elem(b, 1000)
+ }
+
+ fn do_bench_from_slice(b: &mut Bencher, src_len: uint) {
+ let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+
+ b.bytes = src_len as u64;
+
b.iter(|| {
- let v: Vec<int> = Vec::from_fn(5, |_| 5);
- assert!(v.as_slice() == [5, 5, 5, 5, 5]);
- })
+ let dst = Vec::from_slice(src.clone().as_slice());
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+ }
+
+ #[bench]
+ fn bench_from_slice_0000(b: &mut Bencher) {
+ do_bench_from_slice(b, 0)
+ }
+
+ #[bench]
+ fn bench_from_slice_0010(b: &mut Bencher) {
+ do_bench_from_slice(b, 10)
+ }
+
+ #[bench]
+ fn bench_from_slice_0100(b: &mut Bencher) {
+ do_bench_from_slice(b, 100)
}
#[bench]
- fn bench_from_slice_0(b: &mut Bencher) {
+ fn bench_from_slice_1000(b: &mut Bencher) {
+ do_bench_from_slice(b, 1000)
+ }
+
+ fn do_bench_from_iter(b: &mut Bencher, src_len: uint) {
+ let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+
+ b.bytes = src_len as u64;
+
b.iter(|| {
- let v: Vec<int> = Vec::from_slice([]);
- assert!(v.as_slice() == []);
- })
+ let dst: Vec<uint> = FromIterator::from_iter(src.clone().move_iter());
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+ }
+
+ #[bench]
+ fn bench_from_iter_0000(b: &mut Bencher) {
+ do_bench_from_iter(b, 0)
+ }
+
+ #[bench]
+ fn bench_from_iter_0010(b: &mut Bencher) {
+ do_bench_from_iter(b, 10)
+ }
+
+ #[bench]
+ fn bench_from_iter_0100(b: &mut Bencher) {
+ do_bench_from_iter(b, 100)
}
#[bench]
- fn bench_from_slice_5(b: &mut Bencher) {
+ fn bench_from_iter_1000(b: &mut Bencher) {
+ do_bench_from_iter(b, 1000)
+ }
+
+ fn do_bench_extend(b: &mut Bencher, dst_len: uint, src_len: uint) {
+ let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
+ let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+
+ b.bytes = src_len as u64;
+
b.iter(|| {
- let v: Vec<int> = Vec::from_slice([1i, 2, 3, 4, 5]);
- assert!(v.as_slice() == [1, 2, 3, 4, 5]);
- })
+ let mut dst = dst.clone();
+ dst.extend(src.clone().move_iter());
+ assert_eq!(dst.len(), dst_len + src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+ }
+
+ #[bench]
+ fn bench_extend_0000_0000(b: &mut Bencher) {
+ do_bench_extend(b, 0, 0)
+ }
+
+ #[bench]
+ fn bench_extend_0000_0010(b: &mut Bencher) {
+ do_bench_extend(b, 0, 10)
+ }
+
+ #[bench]
+ fn bench_extend_0000_0100(b: &mut Bencher) {
+ do_bench_extend(b, 0, 100)
}
#[bench]
- fn bench_from_iter_0(b: &mut Bencher) {
+ fn bench_extend_0000_1000(b: &mut Bencher) {
+ do_bench_extend(b, 0, 1000)
+ }
+
+ #[bench]
+ fn bench_extend_0010_0010(b: &mut Bencher) {
+ do_bench_extend(b, 10, 10)
+ }
+
+ #[bench]
+ fn bench_extend_0100_0100(b: &mut Bencher) {
+ do_bench_extend(b, 100, 100)
+ }
+
+ #[bench]
+ fn bench_extend_1000_1000(b: &mut Bencher) {
+ do_bench_extend(b, 1000, 1000)
+ }
+
+ fn do_bench_push_all(b: &mut Bencher, dst_len: uint, src_len: uint) {
+ let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
+ let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+
+ b.bytes = src_len as u64;
+
b.iter(|| {
- let v0: Vec<int> = vec!();
- let v1: Vec<int> = FromIterator::from_iter(v0.move_iter());
- assert!(v1.as_slice() == []);
- })
+ let mut dst = dst.clone();
+ dst.push_all(src.as_slice());
+ assert_eq!(dst.len(), dst_len + src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+ }
+
+ #[bench]
+ fn bench_push_all_0000_0000(b: &mut Bencher) {
+ do_bench_push_all(b, 0, 0)
+ }
+
+ #[bench]
+ fn bench_push_all_0000_0010(b: &mut Bencher) {
+ do_bench_push_all(b, 0, 10)
+ }
+
+ #[bench]
+ fn bench_push_all_0000_0100(b: &mut Bencher) {
+ do_bench_push_all(b, 0, 100)
}
#[bench]
- fn bench_from_iter_5(b: &mut Bencher) {
+ fn bench_push_all_0000_1000(b: &mut Bencher) {
+ do_bench_push_all(b, 0, 1000)
+ }
+
+ #[bench]
+ fn bench_push_all_0010_0010(b: &mut Bencher) {
+ do_bench_push_all(b, 10, 10)
+ }
+
+ #[bench]
+ fn bench_push_all_0100_0100(b: &mut Bencher) {
+ do_bench_push_all(b, 100, 100)
+ }
+
+ #[bench]
+ fn bench_push_all_1000_1000(b: &mut Bencher) {
+ do_bench_push_all(b, 1000, 1000)
+ }
+
+ fn do_bench_push_all_move(b: &mut Bencher, dst_len: uint, src_len: uint) {
+ let dst: Vec<uint> = FromIterator::from_iter(range(0u, dst_len));
+ let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+
+ b.bytes = src_len as u64;
+
b.iter(|| {
- let v0: Vec<int> = vec!(1, 2, 3, 4, 5);
- let v1: Vec<int> = FromIterator::from_iter(v0.move_iter());
- assert!(v1.as_slice() == [1, 2, 3, 4, 5]);
- })
+ let mut dst = dst.clone();
+ dst.push_all_move(src.clone());
+ assert_eq!(dst.len(), dst_len + src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
+ }
+
+ #[bench]
+ fn bench_push_all_move_0000_0000(b: &mut Bencher) {
+ do_bench_push_all_move(b, 0, 0)
+ }
+
+ #[bench]
+ fn bench_push_all_move_0000_0010(b: &mut Bencher) {
+ do_bench_push_all_move(b, 0, 10)
+ }
+
+ #[bench]
+ fn bench_push_all_move_0000_0100(b: &mut Bencher) {
+ do_bench_push_all_move(b, 0, 100)
+ }
+
+ #[bench]
+ fn bench_push_all_move_0000_1000(b: &mut Bencher) {
+ do_bench_push_all_move(b, 0, 1000)
}
#[bench]
- fn bench_extend_0(b: &mut Bencher) {
+ fn bench_push_all_move_0010_0010(b: &mut Bencher) {
+ do_bench_push_all_move(b, 10, 10)
+ }
+
+ #[bench]
+ fn bench_push_all_move_0100_0100(b: &mut Bencher) {
+ do_bench_push_all_move(b, 100, 100)
+ }
+
+ #[bench]
+ fn bench_push_all_move_1000_1000(b: &mut Bencher) {
+ do_bench_push_all_move(b, 1000, 1000)
+ }
+
+ fn do_bench_clone(b: &mut Bencher, src_len: uint) {
+ let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+
+ b.bytes = src_len as u64;
+
b.iter(|| {
- let v0: Vec<int> = vec!();
- let mut v1: Vec<int> = vec!(1, 2, 3, 4, 5);
- v1.extend(v0.move_iter());
- assert!(v1.as_slice() == [1, 2, 3, 4, 5]);
- })
+ let dst = src.clone();
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+ });
}
#[bench]
- fn bench_extend_5(b: &mut Bencher) {
+ fn bench_clone_0000(b: &mut Bencher) {
+ do_bench_clone(b, 0)
+ }
+
+ #[bench]
+ fn bench_clone_0010(b: &mut Bencher) {
+ do_bench_clone(b, 10)
+ }
+
+ #[bench]
+ fn bench_clone_0100(b: &mut Bencher) {
+ do_bench_clone(b, 100)
+ }
+
+ #[bench]
+ fn bench_clone_1000(b: &mut Bencher) {
+ do_bench_clone(b, 1000)
+ }
+
+ fn do_bench_clone_from(b: &mut Bencher, times: uint, dst_len: uint, src_len: uint) {
+ let dst: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+ let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+
+ b.bytes = (times * src_len) as u64;
+
b.iter(|| {
- let v0: Vec<int> = vec!(1, 2, 3, 4, 5);
- let mut v1: Vec<int> = vec!(1, 2, 3, 4, 5);
- v1.extend(v0.move_iter());
- assert!(v1.as_slice() == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]);
- })
+ let mut dst = dst.clone();
+
+ for _ in range(0, times) {
+ dst.clone_from(&src);
+
+ assert_eq!(dst.len(), src_len);
+ assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
+ }
+ });
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 0, 0)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 0, 10)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 0, 100)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 0, 1000)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 10, 10)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 100, 100)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 1000, 1000)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 10, 100)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 100, 1000)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 10, 0)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 100, 10)
+ }
+
+ #[bench]
+ fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 1, 1000, 100)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 0, 0)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 0, 10)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 0, 100)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 0, 1000)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 10, 10)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 100, 100)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 1000, 1000)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 10, 100)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 100, 1000)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 10, 0)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 100, 10)
+ }
+
+ #[bench]
+ fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
+ do_bench_clone_from(b, 10, 1000, 100)
}
}
///
/// fn with_lock(spinlock: &Arc<AtomicBool>, f: || -> ()) {
/// // CAS loop until we are able to replace `false` with `true`
- /// while spinlock.compare_and_swap(false, true, SeqCst) == false {
+ /// while spinlock.compare_and_swap(false, true, SeqCst) != false {
/// // Since tasks may not be preemptive (if they are green threads)
/// // yield to the scheduler to let the other task run. Low level
/// // concurrent code needs to take into account Rust's two threading
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//! Character manipulation (`char` type, Unicode Scalar Value)
+//! Character manipulation.
//!
-//! This module provides the `Char` trait, as well as its implementation
-//! for the primitive `char` type, in order to allow basic character manipulation.
-//!
-//! A `char` actually represents a
-//! *[Unicode Scalar Value](http://www.unicode.org/glossary/#unicode_scalar_value)*,
-//! as it can contain any Unicode code point except high-surrogate and
-//! low-surrogate code points.
-//!
-//! As such, only values in the ranges \[0x0,0xD7FF\] and \[0xE000,0x10FFFF\]
-//! (inclusive) are allowed. A `char` can always be safely cast to a `u32`;
-//! however the converse is not always true due to the above range limits
-//! and, as such, should be performed via the `from_u32` function..
+//! For more details, see ::unicode::char (a.k.a. std::char)
#![allow(non_snake_case_functions)]
#![doc(primitive = "char")]
use mem::transmute;
use option::{None, Option, Some};
use iter::{Iterator, range_step};
-use unicode::{derived_property, property, general_category, conversions};
-
-/// Returns the canonical decomposition of a character.
-pub use unicode::normalization::decompose_canonical;
-/// Returns the compatibility decomposition of a character.
-pub use unicode::normalization::decompose_compatible;
// UTF-8 ranges and tags for encoding characters
static TAG_CONT: u8 = 0b1000_0000u8;
}
}
-/// Returns whether the specified `char` is considered a Unicode alphabetic
-/// code point
-pub fn is_alphabetic(c: char) -> bool { derived_property::Alphabetic(c) }
-
-/// Returns whether the specified `char` satisfies the 'XID_Start' Unicode property
-///
-/// 'XID_Start' is a Unicode Derived Property specified in
-/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
-/// mostly similar to ID_Start but modified for closure under NFKx.
-pub fn is_XID_start(c: char) -> bool { derived_property::XID_Start(c) }
-
-/// Returns whether the specified `char` satisfies the 'XID_Continue' Unicode property
-///
-/// 'XID_Continue' is a Unicode Derived Property specified in
-/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
-/// mostly similar to 'ID_Continue' but modified for closure under NFKx.
-pub fn is_XID_continue(c: char) -> bool { derived_property::XID_Continue(c) }
-
-///
-/// Indicates whether a `char` is in lower case
-///
-/// This is defined according to the terms of the Unicode Derived Core Property 'Lowercase'.
-///
-#[inline]
-pub fn is_lowercase(c: char) -> bool { derived_property::Lowercase(c) }
-
-///
-/// Indicates whether a `char` is in upper case
-///
-/// This is defined according to the terms of the Unicode Derived Core Property 'Uppercase'.
-///
-#[inline]
-pub fn is_uppercase(c: char) -> bool { derived_property::Uppercase(c) }
-
-///
-/// Indicates whether a `char` is whitespace
-///
-/// Whitespace is defined in terms of the Unicode Property 'White_Space'.
-///
-#[inline]
-pub fn is_whitespace(c: char) -> bool {
- // As an optimization ASCII whitespace characters are checked separately
- c == ' '
- || ('\x09' <= c && c <= '\x0d')
- || property::White_Space(c)
-}
-
-///
-/// Indicates whether a `char` is alphanumeric
-///
-/// Alphanumericness is defined in terms of the Unicode General Categories
-/// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
-///
-#[inline]
-pub fn is_alphanumeric(c: char) -> bool {
- derived_property::Alphabetic(c)
- || general_category::Nd(c)
- || general_category::Nl(c)
- || general_category::No(c)
-}
-
-///
-/// Indicates whether a `char` is a control code point
-///
-/// Control code points are defined in terms of the Unicode General Category
-/// 'Cc'.
-///
-#[inline]
-pub fn is_control(c: char) -> bool { general_category::Cc(c) }
-
-/// Indicates whether the `char` is numeric (Nd, Nl, or No)
-#[inline]
-pub fn is_digit(c: char) -> bool {
- general_category::Nd(c)
- || general_category::Nl(c)
- || general_category::No(c)
-}
-
///
/// Checks if a `char` parses as a numeric digit in the given radix
///
else { None }
}
-/// Convert a char to its uppercase equivalent
-///
-/// The case-folding performed is the common or simple mapping:
-/// it maps one unicode codepoint (one char in Rust) to its uppercase equivalent according
-/// to the Unicode database at ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
-/// The additional SpecialCasing.txt is not considered here, as it expands to multiple
-/// codepoints in some cases.
-///
-/// A full reference can be found here
-/// http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992
-///
-/// # Return value
-///
-/// Returns the char itself if no conversion was made
-#[inline]
-pub fn to_uppercase(c: char) -> char {
- conversions::to_upper(c)
-}
-
-/// Convert a char to its lowercase equivalent
-///
-/// The case-folding performed is the common or simple mapping
-/// see `to_uppercase` for references and more information
-///
-/// # Return value
-///
-/// Returns the char itself if no conversion if possible
-#[inline]
-pub fn to_lowercase(c: char) -> char {
- conversions::to_lower(c)
-}
-
///
/// Converts a number to the character representing it
///
}
}
-/// Useful functions for Unicode characters.
+/// Basic `char` manipulations.
pub trait Char {
- /// Returns whether the specified character is considered a Unicode
- /// alphabetic code point.
- fn is_alphabetic(&self) -> bool;
-
- /// Returns whether the specified character satisfies the 'XID_Start'
- /// Unicode property.
- ///
- /// 'XID_Start' is a Unicode Derived Property specified in
- /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
- /// mostly similar to ID_Start but modified for closure under NFKx.
- fn is_XID_start(&self) -> bool;
-
- /// Returns whether the specified `char` satisfies the 'XID_Continue'
- /// Unicode property.
- ///
- /// 'XID_Continue' is a Unicode Derived Property specified in
- /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
- /// mostly similar to 'ID_Continue' but modified for closure under NFKx.
- fn is_XID_continue(&self) -> bool;
-
-
- /// Indicates whether a character is in lowercase.
- ///
- /// This is defined according to the terms of the Unicode Derived Core
- /// Property `Lowercase`.
- fn is_lowercase(&self) -> bool;
-
- /// Indicates whether a character is in uppercase.
- ///
- /// This is defined according to the terms of the Unicode Derived Core
- /// Property `Uppercase`.
- fn is_uppercase(&self) -> bool;
-
- /// Indicates whether a character is whitespace.
- ///
- /// Whitespace is defined in terms of the Unicode Property `White_Space`.
- fn is_whitespace(&self) -> bool;
-
- /// Indicates whether a character is alphanumeric.
- ///
- /// Alphanumericness is defined in terms of the Unicode General Categories
- /// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
- fn is_alphanumeric(&self) -> bool;
-
- /// Indicates whether a character is a control code point.
- ///
- /// Control code points are defined in terms of the Unicode General
- /// Category `Cc`.
- fn is_control(&self) -> bool;
-
- /// Indicates whether the character is numeric (Nd, Nl, or No).
- fn is_digit(&self) -> bool;
-
/// Checks if a `char` parses as a numeric digit in the given radix.
///
/// Compared to `is_digit()`, this function only recognizes the characters
/// Fails if given a radix outside the range [0..36].
fn to_digit(&self, radix: uint) -> Option<uint>;
- /// Converts a character to its lowercase equivalent.
- ///
- /// The case-folding performed is the common or simple mapping. See
- /// `to_uppercase()` for references and more information.
- ///
- /// # Return value
- ///
- /// Returns the lowercase equivalent of the character, or the character
- /// itself if no conversion is possible.
- fn to_lowercase(&self) -> char;
-
- /// Converts a character to its uppercase equivalent.
- ///
- /// The case-folding performed is the common or simple mapping: it maps
- /// one unicode codepoint (one character in Rust) to its uppercase
- /// equivalent according to the Unicode database [1]. The additional
- /// `SpecialCasing.txt` is not considered here, as it expands to multiple
- /// codepoints in some cases.
- ///
- /// A full reference can be found here [2].
- ///
- /// # Return value
- ///
- /// Returns the uppercase equivalent of the character, or the character
- /// itself if no conversion was made.
- ///
- /// [1]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
- ///
- /// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992
- fn to_uppercase(&self) -> char;
-
/// Converts a number to the character representing it.
///
/// # Return value
}
impl Char for char {
- fn is_alphabetic(&self) -> bool { is_alphabetic(*self) }
-
- fn is_XID_start(&self) -> bool { is_XID_start(*self) }
-
- fn is_XID_continue(&self) -> bool { is_XID_continue(*self) }
-
- fn is_lowercase(&self) -> bool { is_lowercase(*self) }
-
- fn is_uppercase(&self) -> bool { is_uppercase(*self) }
-
- fn is_whitespace(&self) -> bool { is_whitespace(*self) }
-
- fn is_alphanumeric(&self) -> bool { is_alphanumeric(*self) }
-
- fn is_control(&self) -> bool { is_control(*self) }
-
- fn is_digit(&self) -> bool { is_digit(*self) }
-
fn is_digit_radix(&self, radix: uint) -> bool { is_digit_radix(*self, radix) }
fn to_digit(&self, radix: uint) -> Option<uint> { to_digit(*self, radix) }
- fn to_lowercase(&self) -> char { to_lowercase(*self) }
-
- fn to_uppercase(&self) -> char { to_uppercase(*self) }
-
fn from_digit(num: uint, radix: uint) -> Option<char> { from_digit(num, radix) }
fn escape_unicode(&self, f: |char|) { escape_unicode(*self, f) }
}
}
}
-
-
/// integer, since the conversion would throw away aliasing information.
pub fn offset<T>(dst: *const T, offset: int) -> *const T;
- /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
- /// a size of `count` * `size_of::<T>()` and an alignment of
- /// `min_align_of::<T>()`
+ /// Copies data from one location to another.
+ ///
+ /// Copies `count` elements (not bytes) from `src` to `dst`. The source
+ /// and destination may *not* overlap.
+ ///
+ /// `copy_nonoverlapping_memory` is semantically equivalent to C's `memcpy`.
+ ///
+ /// # Example
+ ///
+ /// A safe swap function:
+ ///
+ /// ```
+ /// use std::mem;
+ /// use std::ptr;
+ ///
+ /// fn swap<T>(x: &mut T, y: &mut T) {
+ /// unsafe {
+ /// // Give ourselves some scratch space to work with
+ /// let mut t: T = mem::uninitialized();
+ ///
+ /// // Perform the swap, `&mut` pointers never alias
+ /// ptr::copy_nonoverlapping_memory(&mut t, &*x, 1);
+ /// ptr::copy_nonoverlapping_memory(x, &*y, 1);
+ /// ptr::copy_nonoverlapping_memory(y, &t, 1);
+ ///
+ /// // y and t now point to the same thing, but we need to completely forget `tmp`
+ /// // because it's no longer relevant.
+ /// mem::forget(t);
+ /// }
+ /// }
+ /// ```
+ ///
+ /// # Safety Note
+ ///
+ /// If the source and destination overlap then the behavior of this
+ /// function is undefined.
+ #[unstable]
pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint);
- /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with
- /// a size of `count` * `size_of::<T>()` and an alignment of
- /// `min_align_of::<T>()`
+ /// Copies data from one location to another.
+ ///
+ /// Copies `count` elements (not bytes) from `src` to `dst`. The source
+ /// and destination may overlap.
+ ///
+ /// `copy_memory` is semantically equivalent to C's `memmove`.
+ ///
+ /// # Example
+ ///
+ /// Efficiently create a Rust vector from an unsafe buffer:
+ ///
+ /// ```
+ /// use std::ptr;
+ ///
+ /// unsafe fn from_buf_raw<T>(ptr: *const T, elts: uint) -> Vec<T> {
+ /// let mut dst = Vec::with_capacity(elts);
+ /// dst.set_len(elts);
+ /// ptr::copy_memory(dst.as_mut_ptr(), ptr, elts);
+ /// dst
+ /// }
+ /// ```
+ ///
+ #[unstable]
pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint);
- /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a
- /// size of `count` * `size_of::<T>()` and an alignment of
- /// `min_align_of::<T>()`
+ /// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
+ /// bytes of memory starting at `dst` to `c`.
+ #[experimental = "uncertain about naming and semantics"]
pub fn set_memory<T>(dst: *mut T, val: u8, count: uint);
/// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
///
/// # Example
///
- /// ```rust
+ /// ```rust,ignore
/// range(0u, 5).advance(|x| {print!("{} ", x); true});
/// ```
+ #[deprecated = "use the `all` method instead"]
#[inline]
fn advance(&mut self, f: |A| -> bool) -> bool {
loop {
/// An double-ended iterator with the direction inverted
#[deriving(Clone)]
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Rev<T> {
iter: T
}
}
/// A mutable reference to an iterator
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct ByRef<'a, T> {
iter: &'a mut T
}
/// An iterator that repeats endlessly
#[deriving(Clone)]
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Cycle<T> {
orig: T,
iter: T,
/// An iterator which strings two iterators together
#[deriving(Clone)]
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Chain<T, U> {
a: T,
b: U,
/// An iterator which iterates two other iterators simultaneously
#[deriving(Clone)]
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Zip<T, U> {
a: T,
b: U
}
/// An iterator which maps the values of `iter` with `f`
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Map<'a, A, B, T> {
iter: T,
f: |A|: 'a -> B
}
/// An iterator which filters the elements of `iter` with `predicate`
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Filter<'a, A, T> {
iter: T,
predicate: |&A|: 'a -> bool
}
/// An iterator which uses `f` to both filter and map elements from `iter`
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct FilterMap<'a, A, B, T> {
iter: T,
f: |A|: 'a -> Option<B>
/// An iterator which yields the current count and the element during iteration
#[deriving(Clone)]
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Enumerate<T> {
iter: T,
count: uint
}
/// An iterator with a `peek()` that returns an optional reference to the next element.
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Peekable<A, T> {
iter: T,
peeked: Option<A>,
}
/// An iterator which rejects elements while `predicate` is true
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct SkipWhile<'a, A, T> {
iter: T,
flag: bool,
}
/// An iterator which only accepts elements while `predicate` is true
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct TakeWhile<'a, A, T> {
iter: T,
flag: bool,
/// An iterator which skips over `n` elements of `iter`.
#[deriving(Clone)]
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Skip<T> {
iter: T,
n: uint
/// An iterator which only iterates over the first `n` iterations of `iter`.
#[deriving(Clone)]
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Take<T> {
iter: T,
n: uint
/// An iterator to maintain state while iterating another iterator
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Scan<'a, A, B, T, St> {
iter: T,
f: |&mut St, A|: 'a -> Option<B>,
/// An iterator that maps each element to an iterator,
/// and yields the elements of the produced iterators
///
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct FlatMap<'a, A, T, U> {
iter: T,
f: |A|: 'a -> U,
/// An iterator that yields `None` forever after the underlying iterator
/// yields `None` once.
#[deriving(Clone)]
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Fuse<T> {
iter: T,
done: bool
/// An iterator that calls a function with a reference to each
/// element before yielding it.
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct Inspect<'a, A, T> {
iter: T,
f: |&A|: 'a
}
}
}
-
// Since libcore defines many fundamental lang items, all tests live in a
// separate crate, libcoretest, to avoid bizarre issues.
-#![crate_id = "core#0.11.0"]
#![crate_name = "core"]
#![experimental]
#![license = "MIT/ASL2"]
#![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
#![feature(simd, unsafe_destructor)]
#![deny(missing_doc)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
mod macros;
/* Core types and methods on primitives */
-mod unicode;
pub mod any;
pub mod atomics;
pub mod bool;
//! Operations and constants for 32-bits floats (`f32` type)
#![doc(primitive = "f32")]
+// FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353
+#![allow(type_overflow)]
use intrinsics;
use mem;
//! Operations and constants for 64-bits floats (`f64` type)
#![doc(primitive = "f64")]
+// FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353
+#![allow(type_overflow)]
use intrinsics;
use mem;
* ```
*/
#[lang="index"]
-#[cfg(not(stage0))]
pub trait Index<Index,Result> {
/// The method for the indexing (`Foo[Bar]`) operation
fn index<'a>(&'a self, index: &Index) -> &'a Result;
* ```
*/
#[lang="index_mut"]
-#[cfg(not(stage0))]
pub trait IndexMut<Index,Result> {
/// The method for the indexing (`Foo[Bar]`) operation
fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Result;
pub use ops::{BitAnd, BitOr, BitXor};
pub use ops::{Drop, Deref, DerefMut};
pub use ops::{Shl, Shr};
-#[cfg(not(stage0))]
pub use ops::{Index, IndexMut};
pub use option::{Option, Some, None};
pub use result::{Result, Ok, Err};
use cmp::{PartialEq, Eq, PartialOrd, Equiv, Ordering, Less, Equal, Greater};
+pub use intrinsics::copy_memory;
+pub use intrinsics::copy_nonoverlapping_memory;
+pub use intrinsics::set_memory;
+
/// Create a null pointer.
///
/// # Example
#[unstable = "may need a different name after pending changes to pointer types"]
pub fn mut_null<T>() -> *mut T { 0 as *mut T }
-/// Copies data from one location to another.
-///
-/// Copies `count` elements (not bytes) from `src` to `dst`. The source
-/// and destination may overlap.
-///
-/// `copy_memory` is semantically equivalent to C's `memmove`.
-///
-/// # Example
-///
-/// Efficiently create a Rust vector from an unsafe buffer:
-///
-/// ```
-/// use std::ptr;
-///
-/// unsafe fn from_buf_raw<T>(ptr: *const T, elts: uint) -> Vec<T> {
-/// let mut dst = Vec::with_capacity(elts);
-/// dst.set_len(elts);
-/// ptr::copy_memory(dst.as_mut_ptr(), ptr, elts);
-/// dst
-/// }
-/// ```
-///
-#[inline]
-#[unstable]
-pub unsafe fn copy_memory<T>(dst: *mut T, src: *const T, count: uint) {
- intrinsics::copy_memory(dst, src, count)
-}
-
-/// Copies data from one location to another.
-///
-/// Copies `count` elements (not bytes) from `src` to `dst`. The source
-/// and destination may *not* overlap.
-///
-/// `copy_nonoverlapping_memory` is semantically equivalent to C's `memcpy`.
-///
-/// # Example
-///
-/// A safe swap function:
-///
-/// ```
-/// use std::mem;
-/// use std::ptr;
-///
-/// fn swap<T>(x: &mut T, y: &mut T) {
-/// unsafe {
-/// // Give ourselves some scratch space to work with
-/// let mut t: T = mem::uninitialized();
-///
-/// // Perform the swap, `&mut` pointers never alias
-/// ptr::copy_nonoverlapping_memory(&mut t, &*x, 1);
-/// ptr::copy_nonoverlapping_memory(x, &*y, 1);
-/// ptr::copy_nonoverlapping_memory(y, &t, 1);
-///
-/// // y and t now point to the same thing, but we need to completely forget `tmp`
-/// // because it's no longer relevant.
-/// mem::forget(t);
-/// }
-/// }
-/// ```
-///
-/// # Safety Note
-///
-/// If the source and destination overlap then the behavior of this
-/// function is undefined.
-#[inline]
-#[unstable]
-pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T,
- src: *const T,
- count: uint) {
- intrinsics::copy_nonoverlapping_memory(dst, src, count)
-}
-
-/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
-/// bytes of memory starting at `dst` to `c`.
-#[inline]
-#[experimental = "uncertain about naming and semantics"]
-pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
- intrinsics::set_memory(dst, c, count)
-}
-
/// Zeroes out `count * size_of::<T>` bytes of memory at `dst`
#[inline]
#[experimental = "uncertain about naming and semantics"]
use cmp::{PartialEq, Eq};
use collections::Collection;
use default::Default;
-use iter::{Filter, Map, Iterator};
+use iter::{Map, Iterator};
use iter::{DoubleEndedIterator, ExactSize};
use iter::range;
use num::{CheckedMul, Saturating};
invert: bool,
}
-/// An iterator over the words of a string, separated by a sequence of whitespace
-pub type Words<'a> =
- Filter<'a, &'a str, CharSplits<'a, extern "Rust" fn(char) -> bool>>;
-
/// An iterator over the lines of a string, separated by either `\n` or (`\r\n`).
pub type AnyLines<'a> =
Map<'a, &'a str, &'a str, CharSplits<'a, char>>;
/// ```
fn lines_any(&self) -> AnyLines<'a>;
- /// An iterator over the words of a string (subsequences separated
- /// by any sequence of whitespace). Sequences of whitespace are
- /// collapsed, so empty "words" are not included.
- ///
- /// # Example
- ///
- /// ```rust
- /// let some_words = " Mary had\ta little \n\t lamb";
- /// let v: Vec<&str> = some_words.words().collect();
- /// assert_eq!(v, vec!["Mary", "had", "a", "little", "lamb"]);
- /// ```
- fn words(&self) -> Words<'a>;
-
- /// Returns true if the string contains only whitespace.
- ///
- /// Whitespace characters are determined by `char::is_whitespace`.
- ///
- /// # Example
- ///
- /// ```rust
- /// assert!(" \t\n".is_whitespace());
- /// assert!("".is_whitespace());
- ///
- /// assert!( !"abc".is_whitespace());
- /// ```
- fn is_whitespace(&self) -> bool;
-
- /// Returns true if the string contains only alphanumeric code
- /// points.
- ///
- /// Alphanumeric characters are determined by `char::is_alphanumeric`.
- ///
- /// # Example
- ///
- /// ```rust
- /// assert!("Löwe老虎Léopard123".is_alphanumeric());
- /// assert!("".is_alphanumeric());
- ///
- /// assert!( !" &*~".is_alphanumeric());
- /// ```
- fn is_alphanumeric(&self) -> bool;
-
/// Returns the number of Unicode code points (`char`) that a
/// string holds.
///
/// Returns true if `needle` is a suffix of the string.
fn ends_with(&self, needle: &str) -> bool;
- /// Returns a string with leading and trailing whitespace removed.
- fn trim(&self) -> &'a str;
-
- /// Returns a string with leading whitespace removed.
- fn trim_left(&self) -> &'a str;
-
- /// Returns a string with trailing whitespace removed.
- fn trim_right(&self) -> &'a str;
-
/// Returns a string with characters that match `to_trim` removed.
///
/// # Arguments
})
}
- #[inline]
- fn words(&self) -> Words<'a> {
- self.split(char::is_whitespace).filter(|s| !s.is_empty())
- }
-
- #[inline]
- fn is_whitespace(&self) -> bool { self.chars().all(char::is_whitespace) }
-
- #[inline]
- fn is_alphanumeric(&self) -> bool { self.chars().all(char::is_alphanumeric) }
-
#[inline]
fn char_len(&self) -> uint { self.chars().count() }
m >= n && needle.as_bytes() == self.as_bytes().slice_from(m - n)
}
- #[inline]
- fn trim(&self) -> &'a str {
- self.trim_left().trim_right()
- }
-
- #[inline]
- fn trim_left(&self) -> &'a str {
- self.trim_left_chars(char::is_whitespace)
- }
-
- #[inline]
- fn trim_right(&self) -> &'a str {
- self.trim_right_chars(char::is_whitespace)
- }
-
#[inline]
fn trim_chars<C: CharEq>(&self, mut to_trim: C) -> &'a str {
let cur = match self.find(|c: char| !to_trim.matches(c)) {
+++ /dev/null
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// NOTE: The following code was generated by "src/etc/unicode.py", do not edit directly
-
-#![allow(missing_doc, non_uppercase_statics, non_snake_case_functions)]
-
-
-fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
- use cmp::{Equal, Less, Greater};
- use slice::ImmutableVector;
- use option::None;
- r.bsearch(|&(lo,hi)| {
- if lo <= c && c <= hi { Equal }
- else if hi < c { Less }
- else { Greater }
- }) != None
-}
-
-pub mod general_category {
- static Cc_table : &'static [(char,char)] = &[
- ('\x00', '\x1f'), ('\x7f', '\x9f')
- ];
-
- pub fn Cc(c: char) -> bool {
- super::bsearch_range_table(c, Cc_table)
- }
-
- static Nd_table : &'static [(char,char)] = &[
- ('\x30', '\x39'), ('\u0660', '\u0669'),
- ('\u06f0', '\u06f9'), ('\u07c0', '\u07c9'),
- ('\u0966', '\u096f'), ('\u09e6', '\u09ef'),
- ('\u0a66', '\u0a6f'), ('\u0ae6', '\u0aef'),
- ('\u0b66', '\u0b6f'), ('\u0be6', '\u0bef'),
- ('\u0c66', '\u0c6f'), ('\u0ce6', '\u0cef'),
- ('\u0d66', '\u0d6f'), ('\u0e50', '\u0e59'),
- ('\u0ed0', '\u0ed9'), ('\u0f20', '\u0f29'),
- ('\u1040', '\u1049'), ('\u1090', '\u1099'),
- ('\u17e0', '\u17e9'), ('\u1810', '\u1819'),
- ('\u1946', '\u194f'), ('\u19d0', '\u19d9'),
- ('\u1a80', '\u1a99'), ('\u1b50', '\u1b59'),
- ('\u1bb0', '\u1bb9'), ('\u1c40', '\u1c49'),
- ('\u1c50', '\u1c59'), ('\ua620', '\ua629'),
- ('\ua8d0', '\ua8d9'), ('\ua900', '\ua909'),
- ('\ua9d0', '\ua9d9'), ('\uaa50', '\uaa59'),
- ('\uabf0', '\uabf9'), ('\uff10', '\uff19'),
- ('\U000104a0', '\U000104a9'), ('\U00011066', '\U0001106f'),
- ('\U000110f0', '\U000110f9'), ('\U00011136', '\U0001113f'),
- ('\U000111d0', '\U000111d9'), ('\U000116c0', '\U000116c9'),
- ('\U0001d7ce', '\U0001d7ff')
- ];
-
- pub fn Nd(c: char) -> bool {
- super::bsearch_range_table(c, Nd_table)
- }
-
- static Nl_table : &'static [(char,char)] = &[
- ('\u16ee', '\u16f0'), ('\u2160', '\u2182'),
- ('\u2185', '\u2188'), ('\u3007', '\u3007'),
- ('\u3021', '\u3029'), ('\u3038', '\u303a'),
- ('\ua6e6', '\ua6ef'), ('\U00010140', '\U00010174'),
- ('\U00010341', '\U00010341'), ('\U0001034a', '\U0001034a'),
- ('\U000103d1', '\U000103d5'), ('\U00012400', '\U00012462')
- ];
-
- pub fn Nl(c: char) -> bool {
- super::bsearch_range_table(c, Nl_table)
- }
-
- static No_table : &'static [(char,char)] = &[
- ('\xb2', '\xb3'), ('\xb9', '\xb9'),
- ('\xbc', '\xbe'), ('\u09f4', '\u09f9'),
- ('\u0b72', '\u0b77'), ('\u0bf0', '\u0bf2'),
- ('\u0c78', '\u0c7e'), ('\u0d70', '\u0d75'),
- ('\u0f2a', '\u0f33'), ('\u1369', '\u137c'),
- ('\u17f0', '\u17f9'), ('\u19da', '\u19da'),
- ('\u2070', '\u2070'), ('\u2074', '\u2079'),
- ('\u2080', '\u2089'), ('\u2150', '\u215f'),
- ('\u2189', '\u2189'), ('\u2460', '\u249b'),
- ('\u24ea', '\u24ff'), ('\u2776', '\u2793'),
- ('\u2cfd', '\u2cfd'), ('\u3192', '\u3195'),
- ('\u3220', '\u3229'), ('\u3248', '\u324f'),
- ('\u3251', '\u325f'), ('\u3280', '\u3289'),
- ('\u32b1', '\u32bf'), ('\ua830', '\ua835'),
- ('\U00010107', '\U00010133'), ('\U00010175', '\U00010178'),
- ('\U0001018a', '\U0001018a'), ('\U00010320', '\U00010323'),
- ('\U00010858', '\U0001085f'), ('\U00010916', '\U0001091b'),
- ('\U00010a40', '\U00010a47'), ('\U00010a7d', '\U00010a7e'),
- ('\U00010b58', '\U00010b5f'), ('\U00010b78', '\U00010b7f'),
- ('\U00010e60', '\U00010e7e'), ('\U00011052', '\U00011065'),
- ('\U0001d360', '\U0001d371'), ('\U0001f100', '\U0001f10a')
- ];
-
- pub fn No(c: char) -> bool {
- super::bsearch_range_table(c, No_table)
- }
-
-}
-
-pub mod normalization {
- use option::Option;
- use option::{Some, None};
- use slice::ImmutableVector;
-
- fn bsearch_table(c: char, r: &'static [(char, &'static [char])]) -> Option<&'static [char]> {
- use cmp::{Equal, Less, Greater};
- match r.bsearch(|&(val, _)| {
- if c == val { Equal }
- else if val < c { Less }
- else { Greater }
- }) {
- Some(idx) => {
- let (_, result) = r[idx];
- Some(result)
- }
- None => None
- }
- }
-
-
- // Canonical decompositions
- static canonical_table : &'static [(char, &'static [char])] = &[
- ('\xc0', &['\x41', '\u0300']), ('\xc1', &['\x41', '\u0301']), ('\xc2', &['\x41', '\u0302']),
- ('\xc3', &['\x41', '\u0303']), ('\xc4', &['\x41', '\u0308']), ('\xc5', &['\x41', '\u030a']),
- ('\xc7', &['\x43', '\u0327']), ('\xc8', &['\x45', '\u0300']), ('\xc9', &['\x45', '\u0301']),
- ('\xca', &['\x45', '\u0302']), ('\xcb', &['\x45', '\u0308']), ('\xcc', &['\x49', '\u0300']),
- ('\xcd', &['\x49', '\u0301']), ('\xce', &['\x49', '\u0302']), ('\xcf', &['\x49', '\u0308']),
- ('\xd1', &['\x4e', '\u0303']), ('\xd2', &['\x4f', '\u0300']), ('\xd3', &['\x4f', '\u0301']),
- ('\xd4', &['\x4f', '\u0302']), ('\xd5', &['\x4f', '\u0303']), ('\xd6', &['\x4f', '\u0308']),
- ('\xd9', &['\x55', '\u0300']), ('\xda', &['\x55', '\u0301']), ('\xdb', &['\x55', '\u0302']),
- ('\xdc', &['\x55', '\u0308']), ('\xdd', &['\x59', '\u0301']), ('\xe0', &['\x61', '\u0300']),
- ('\xe1', &['\x61', '\u0301']), ('\xe2', &['\x61', '\u0302']), ('\xe3', &['\x61', '\u0303']),
- ('\xe4', &['\x61', '\u0308']), ('\xe5', &['\x61', '\u030a']), ('\xe7', &['\x63', '\u0327']),
- ('\xe8', &['\x65', '\u0300']), ('\xe9', &['\x65', '\u0301']), ('\xea', &['\x65', '\u0302']),
- ('\xeb', &['\x65', '\u0308']), ('\xec', &['\x69', '\u0300']), ('\xed', &['\x69', '\u0301']),
- ('\xee', &['\x69', '\u0302']), ('\xef', &['\x69', '\u0308']), ('\xf1', &['\x6e', '\u0303']),
- ('\xf2', &['\x6f', '\u0300']), ('\xf3', &['\x6f', '\u0301']), ('\xf4', &['\x6f', '\u0302']),
- ('\xf5', &['\x6f', '\u0303']), ('\xf6', &['\x6f', '\u0308']), ('\xf9', &['\x75', '\u0300']),
- ('\xfa', &['\x75', '\u0301']), ('\xfb', &['\x75', '\u0302']), ('\xfc', &['\x75', '\u0308']),
- ('\xfd', &['\x79', '\u0301']), ('\xff', &['\x79', '\u0308']), ('\u0100', &['\x41',
- '\u0304']), ('\u0101', &['\x61', '\u0304']), ('\u0102', &['\x41', '\u0306']), ('\u0103',
- &['\x61', '\u0306']), ('\u0104', &['\x41', '\u0328']), ('\u0105', &['\x61', '\u0328']),
- ('\u0106', &['\x43', '\u0301']), ('\u0107', &['\x63', '\u0301']), ('\u0108', &['\x43',
- '\u0302']), ('\u0109', &['\x63', '\u0302']), ('\u010a', &['\x43', '\u0307']), ('\u010b',
- &['\x63', '\u0307']), ('\u010c', &['\x43', '\u030c']), ('\u010d', &['\x63', '\u030c']),
- ('\u010e', &['\x44', '\u030c']), ('\u010f', &['\x64', '\u030c']), ('\u0112', &['\x45',
- '\u0304']), ('\u0113', &['\x65', '\u0304']), ('\u0114', &['\x45', '\u0306']), ('\u0115',
- &['\x65', '\u0306']), ('\u0116', &['\x45', '\u0307']), ('\u0117', &['\x65', '\u0307']),
- ('\u0118', &['\x45', '\u0328']), ('\u0119', &['\x65', '\u0328']), ('\u011a', &['\x45',
- '\u030c']), ('\u011b', &['\x65', '\u030c']), ('\u011c', &['\x47', '\u0302']), ('\u011d',
- &['\x67', '\u0302']), ('\u011e', &['\x47', '\u0306']), ('\u011f', &['\x67', '\u0306']),
- ('\u0120', &['\x47', '\u0307']), ('\u0121', &['\x67', '\u0307']), ('\u0122', &['\x47',
- '\u0327']), ('\u0123', &['\x67', '\u0327']), ('\u0124', &['\x48', '\u0302']), ('\u0125',
- &['\x68', '\u0302']), ('\u0128', &['\x49', '\u0303']), ('\u0129', &['\x69', '\u0303']),
- ('\u012a', &['\x49', '\u0304']), ('\u012b', &['\x69', '\u0304']), ('\u012c', &['\x49',
- '\u0306']), ('\u012d', &['\x69', '\u0306']), ('\u012e', &['\x49', '\u0328']), ('\u012f',
- &['\x69', '\u0328']), ('\u0130', &['\x49', '\u0307']), ('\u0134', &['\x4a', '\u0302']),
- ('\u0135', &['\x6a', '\u0302']), ('\u0136', &['\x4b', '\u0327']), ('\u0137', &['\x6b',
- '\u0327']), ('\u0139', &['\x4c', '\u0301']), ('\u013a', &['\x6c', '\u0301']), ('\u013b',
- &['\x4c', '\u0327']), ('\u013c', &['\x6c', '\u0327']), ('\u013d', &['\x4c', '\u030c']),
- ('\u013e', &['\x6c', '\u030c']), ('\u0143', &['\x4e', '\u0301']), ('\u0144', &['\x6e',
- '\u0301']), ('\u0145', &['\x4e', '\u0327']), ('\u0146', &['\x6e', '\u0327']), ('\u0147',
- &['\x4e', '\u030c']), ('\u0148', &['\x6e', '\u030c']), ('\u014c', &['\x4f', '\u0304']),
- ('\u014d', &['\x6f', '\u0304']), ('\u014e', &['\x4f', '\u0306']), ('\u014f', &['\x6f',
- '\u0306']), ('\u0150', &['\x4f', '\u030b']), ('\u0151', &['\x6f', '\u030b']), ('\u0154',
- &['\x52', '\u0301']), ('\u0155', &['\x72', '\u0301']), ('\u0156', &['\x52', '\u0327']),
- ('\u0157', &['\x72', '\u0327']), ('\u0158', &['\x52', '\u030c']), ('\u0159', &['\x72',
- '\u030c']), ('\u015a', &['\x53', '\u0301']), ('\u015b', &['\x73', '\u0301']), ('\u015c',
- &['\x53', '\u0302']), ('\u015d', &['\x73', '\u0302']), ('\u015e', &['\x53', '\u0327']),
- ('\u015f', &['\x73', '\u0327']), ('\u0160', &['\x53', '\u030c']), ('\u0161', &['\x73',
- '\u030c']), ('\u0162', &['\x54', '\u0327']), ('\u0163', &['\x74', '\u0327']), ('\u0164',
- &['\x54', '\u030c']), ('\u0165', &['\x74', '\u030c']), ('\u0168', &['\x55', '\u0303']),
- ('\u0169', &['\x75', '\u0303']), ('\u016a', &['\x55', '\u0304']), ('\u016b', &['\x75',
- '\u0304']), ('\u016c', &['\x55', '\u0306']), ('\u016d', &['\x75', '\u0306']), ('\u016e',
- &['\x55', '\u030a']), ('\u016f', &['\x75', '\u030a']), ('\u0170', &['\x55', '\u030b']),
- ('\u0171', &['\x75', '\u030b']), ('\u0172', &['\x55', '\u0328']), ('\u0173', &['\x75',
- '\u0328']), ('\u0174', &['\x57', '\u0302']), ('\u0175', &['\x77', '\u0302']), ('\u0176',
- &['\x59', '\u0302']), ('\u0177', &['\x79', '\u0302']), ('\u0178', &['\x59', '\u0308']),
- ('\u0179', &['\x5a', '\u0301']), ('\u017a', &['\x7a', '\u0301']), ('\u017b', &['\x5a',
- '\u0307']), ('\u017c', &['\x7a', '\u0307']), ('\u017d', &['\x5a', '\u030c']), ('\u017e',
- &['\x7a', '\u030c']), ('\u01a0', &['\x4f', '\u031b']), ('\u01a1', &['\x6f', '\u031b']),
- ('\u01af', &['\x55', '\u031b']), ('\u01b0', &['\x75', '\u031b']), ('\u01cd', &['\x41',
- '\u030c']), ('\u01ce', &['\x61', '\u030c']), ('\u01cf', &['\x49', '\u030c']), ('\u01d0',
- &['\x69', '\u030c']), ('\u01d1', &['\x4f', '\u030c']), ('\u01d2', &['\x6f', '\u030c']),
- ('\u01d3', &['\x55', '\u030c']), ('\u01d4', &['\x75', '\u030c']), ('\u01d5', &['\xdc',
- '\u0304']), ('\u01d6', &['\xfc', '\u0304']), ('\u01d7', &['\xdc', '\u0301']), ('\u01d8',
- &['\xfc', '\u0301']), ('\u01d9', &['\xdc', '\u030c']), ('\u01da', &['\xfc', '\u030c']),
- ('\u01db', &['\xdc', '\u0300']), ('\u01dc', &['\xfc', '\u0300']), ('\u01de', &['\xc4',
- '\u0304']), ('\u01df', &['\xe4', '\u0304']), ('\u01e0', &['\u0226', '\u0304']), ('\u01e1',
- &['\u0227', '\u0304']), ('\u01e2', &['\xc6', '\u0304']), ('\u01e3', &['\xe6', '\u0304']),
- ('\u01e6', &['\x47', '\u030c']), ('\u01e7', &['\x67', '\u030c']), ('\u01e8', &['\x4b',
- '\u030c']), ('\u01e9', &['\x6b', '\u030c']), ('\u01ea', &['\x4f', '\u0328']), ('\u01eb',
- &['\x6f', '\u0328']), ('\u01ec', &['\u01ea', '\u0304']), ('\u01ed', &['\u01eb', '\u0304']),
- ('\u01ee', &['\u01b7', '\u030c']), ('\u01ef', &['\u0292', '\u030c']), ('\u01f0', &['\x6a',
- '\u030c']), ('\u01f4', &['\x47', '\u0301']), ('\u01f5', &['\x67', '\u0301']), ('\u01f8',
- &['\x4e', '\u0300']), ('\u01f9', &['\x6e', '\u0300']), ('\u01fa', &['\xc5', '\u0301']),
- ('\u01fb', &['\xe5', '\u0301']), ('\u01fc', &['\xc6', '\u0301']), ('\u01fd', &['\xe6',
- '\u0301']), ('\u01fe', &['\xd8', '\u0301']), ('\u01ff', &['\xf8', '\u0301']), ('\u0200',
- &['\x41', '\u030f']), ('\u0201', &['\x61', '\u030f']), ('\u0202', &['\x41', '\u0311']),
- ('\u0203', &['\x61', '\u0311']), ('\u0204', &['\x45', '\u030f']), ('\u0205', &['\x65',
- '\u030f']), ('\u0206', &['\x45', '\u0311']), ('\u0207', &['\x65', '\u0311']), ('\u0208',
- &['\x49', '\u030f']), ('\u0209', &['\x69', '\u030f']), ('\u020a', &['\x49', '\u0311']),
- ('\u020b', &['\x69', '\u0311']), ('\u020c', &['\x4f', '\u030f']), ('\u020d', &['\x6f',
- '\u030f']), ('\u020e', &['\x4f', '\u0311']), ('\u020f', &['\x6f', '\u0311']), ('\u0210',
- &['\x52', '\u030f']), ('\u0211', &['\x72', '\u030f']), ('\u0212', &['\x52', '\u0311']),
- ('\u0213', &['\x72', '\u0311']), ('\u0214', &['\x55', '\u030f']), ('\u0215', &['\x75',
- '\u030f']), ('\u0216', &['\x55', '\u0311']), ('\u0217', &['\x75', '\u0311']), ('\u0218',
- &['\x53', '\u0326']), ('\u0219', &['\x73', '\u0326']), ('\u021a', &['\x54', '\u0326']),
- ('\u021b', &['\x74', '\u0326']), ('\u021e', &['\x48', '\u030c']), ('\u021f', &['\x68',
- '\u030c']), ('\u0226', &['\x41', '\u0307']), ('\u0227', &['\x61', '\u0307']), ('\u0228',
- &['\x45', '\u0327']), ('\u0229', &['\x65', '\u0327']), ('\u022a', &['\xd6', '\u0304']),
- ('\u022b', &['\xf6', '\u0304']), ('\u022c', &['\xd5', '\u0304']), ('\u022d', &['\xf5',
- '\u0304']), ('\u022e', &['\x4f', '\u0307']), ('\u022f', &['\x6f', '\u0307']), ('\u0230',
- &['\u022e', '\u0304']), ('\u0231', &['\u022f', '\u0304']), ('\u0232', &['\x59', '\u0304']),
- ('\u0233', &['\x79', '\u0304']), ('\u0340', &['\u0300']), ('\u0341', &['\u0301']),
- ('\u0343', &['\u0313']), ('\u0344', &['\u0308', '\u0301']), ('\u0374', &['\u02b9']),
- ('\u037e', &['\x3b']), ('\u0385', &['\xa8', '\u0301']), ('\u0386', &['\u0391', '\u0301']),
- ('\u0387', &['\xb7']), ('\u0388', &['\u0395', '\u0301']), ('\u0389', &['\u0397', '\u0301']),
- ('\u038a', &['\u0399', '\u0301']), ('\u038c', &['\u039f', '\u0301']), ('\u038e', &['\u03a5',
- '\u0301']), ('\u038f', &['\u03a9', '\u0301']), ('\u0390', &['\u03ca', '\u0301']), ('\u03aa',
- &['\u0399', '\u0308']), ('\u03ab', &['\u03a5', '\u0308']), ('\u03ac', &['\u03b1',
- '\u0301']), ('\u03ad', &['\u03b5', '\u0301']), ('\u03ae', &['\u03b7', '\u0301']), ('\u03af',
- &['\u03b9', '\u0301']), ('\u03b0', &['\u03cb', '\u0301']), ('\u03ca', &['\u03b9',
- '\u0308']), ('\u03cb', &['\u03c5', '\u0308']), ('\u03cc', &['\u03bf', '\u0301']), ('\u03cd',
- &['\u03c5', '\u0301']), ('\u03ce', &['\u03c9', '\u0301']), ('\u03d3', &['\u03d2',
- '\u0301']), ('\u03d4', &['\u03d2', '\u0308']), ('\u0400', &['\u0415', '\u0300']), ('\u0401',
- &['\u0415', '\u0308']), ('\u0403', &['\u0413', '\u0301']), ('\u0407', &['\u0406',
- '\u0308']), ('\u040c', &['\u041a', '\u0301']), ('\u040d', &['\u0418', '\u0300']), ('\u040e',
- &['\u0423', '\u0306']), ('\u0419', &['\u0418', '\u0306']), ('\u0439', &['\u0438',
- '\u0306']), ('\u0450', &['\u0435', '\u0300']), ('\u0451', &['\u0435', '\u0308']), ('\u0453',
- &['\u0433', '\u0301']), ('\u0457', &['\u0456', '\u0308']), ('\u045c', &['\u043a',
- '\u0301']), ('\u045d', &['\u0438', '\u0300']), ('\u045e', &['\u0443', '\u0306']), ('\u0476',
- &['\u0474', '\u030f']), ('\u0477', &['\u0475', '\u030f']), ('\u04c1', &['\u0416',
- '\u0306']), ('\u04c2', &['\u0436', '\u0306']), ('\u04d0', &['\u0410', '\u0306']), ('\u04d1',
- &['\u0430', '\u0306']), ('\u04d2', &['\u0410', '\u0308']), ('\u04d3', &['\u0430',
- '\u0308']), ('\u04d6', &['\u0415', '\u0306']), ('\u04d7', &['\u0435', '\u0306']), ('\u04da',
- &['\u04d8', '\u0308']), ('\u04db', &['\u04d9', '\u0308']), ('\u04dc', &['\u0416',
- '\u0308']), ('\u04dd', &['\u0436', '\u0308']), ('\u04de', &['\u0417', '\u0308']), ('\u04df',
- &['\u0437', '\u0308']), ('\u04e2', &['\u0418', '\u0304']), ('\u04e3', &['\u0438',
- '\u0304']), ('\u04e4', &['\u0418', '\u0308']), ('\u04e5', &['\u0438', '\u0308']), ('\u04e6',
- &['\u041e', '\u0308']), ('\u04e7', &['\u043e', '\u0308']), ('\u04ea', &['\u04e8',
- '\u0308']), ('\u04eb', &['\u04e9', '\u0308']), ('\u04ec', &['\u042d', '\u0308']), ('\u04ed',
- &['\u044d', '\u0308']), ('\u04ee', &['\u0423', '\u0304']), ('\u04ef', &['\u0443',
- '\u0304']), ('\u04f0', &['\u0423', '\u0308']), ('\u04f1', &['\u0443', '\u0308']), ('\u04f2',
- &['\u0423', '\u030b']), ('\u04f3', &['\u0443', '\u030b']), ('\u04f4', &['\u0427',
- '\u0308']), ('\u04f5', &['\u0447', '\u0308']), ('\u04f8', &['\u042b', '\u0308']), ('\u04f9',
- &['\u044b', '\u0308']), ('\u0622', &['\u0627', '\u0653']), ('\u0623', &['\u0627',
- '\u0654']), ('\u0624', &['\u0648', '\u0654']), ('\u0625', &['\u0627', '\u0655']), ('\u0626',
- &['\u064a', '\u0654']), ('\u06c0', &['\u06d5', '\u0654']), ('\u06c2', &['\u06c1',
- '\u0654']), ('\u06d3', &['\u06d2', '\u0654']), ('\u0929', &['\u0928', '\u093c']), ('\u0931',
- &['\u0930', '\u093c']), ('\u0934', &['\u0933', '\u093c']), ('\u0958', &['\u0915',
- '\u093c']), ('\u0959', &['\u0916', '\u093c']), ('\u095a', &['\u0917', '\u093c']), ('\u095b',
- &['\u091c', '\u093c']), ('\u095c', &['\u0921', '\u093c']), ('\u095d', &['\u0922',
- '\u093c']), ('\u095e', &['\u092b', '\u093c']), ('\u095f', &['\u092f', '\u093c']), ('\u09cb',
- &['\u09c7', '\u09be']), ('\u09cc', &['\u09c7', '\u09d7']), ('\u09dc', &['\u09a1',
- '\u09bc']), ('\u09dd', &['\u09a2', '\u09bc']), ('\u09df', &['\u09af', '\u09bc']), ('\u0a33',
- &['\u0a32', '\u0a3c']), ('\u0a36', &['\u0a38', '\u0a3c']), ('\u0a59', &['\u0a16',
- '\u0a3c']), ('\u0a5a', &['\u0a17', '\u0a3c']), ('\u0a5b', &['\u0a1c', '\u0a3c']), ('\u0a5e',
- &['\u0a2b', '\u0a3c']), ('\u0b48', &['\u0b47', '\u0b56']), ('\u0b4b', &['\u0b47',
- '\u0b3e']), ('\u0b4c', &['\u0b47', '\u0b57']), ('\u0b5c', &['\u0b21', '\u0b3c']), ('\u0b5d',
- &['\u0b22', '\u0b3c']), ('\u0b94', &['\u0b92', '\u0bd7']), ('\u0bca', &['\u0bc6',
- '\u0bbe']), ('\u0bcb', &['\u0bc7', '\u0bbe']), ('\u0bcc', &['\u0bc6', '\u0bd7']), ('\u0c48',
- &['\u0c46', '\u0c56']), ('\u0cc0', &['\u0cbf', '\u0cd5']), ('\u0cc7', &['\u0cc6',
- '\u0cd5']), ('\u0cc8', &['\u0cc6', '\u0cd6']), ('\u0cca', &['\u0cc6', '\u0cc2']), ('\u0ccb',
- &['\u0cca', '\u0cd5']), ('\u0d4a', &['\u0d46', '\u0d3e']), ('\u0d4b', &['\u0d47',
- '\u0d3e']), ('\u0d4c', &['\u0d46', '\u0d57']), ('\u0dda', &['\u0dd9', '\u0dca']), ('\u0ddc',
- &['\u0dd9', '\u0dcf']), ('\u0ddd', &['\u0ddc', '\u0dca']), ('\u0dde', &['\u0dd9',
- '\u0ddf']), ('\u0f43', &['\u0f42', '\u0fb7']), ('\u0f4d', &['\u0f4c', '\u0fb7']), ('\u0f52',
- &['\u0f51', '\u0fb7']), ('\u0f57', &['\u0f56', '\u0fb7']), ('\u0f5c', &['\u0f5b',
- '\u0fb7']), ('\u0f69', &['\u0f40', '\u0fb5']), ('\u0f73', &['\u0f71', '\u0f72']), ('\u0f75',
- &['\u0f71', '\u0f74']), ('\u0f76', &['\u0fb2', '\u0f80']), ('\u0f78', &['\u0fb3',
- '\u0f80']), ('\u0f81', &['\u0f71', '\u0f80']), ('\u0f93', &['\u0f92', '\u0fb7']), ('\u0f9d',
- &['\u0f9c', '\u0fb7']), ('\u0fa2', &['\u0fa1', '\u0fb7']), ('\u0fa7', &['\u0fa6',
- '\u0fb7']), ('\u0fac', &['\u0fab', '\u0fb7']), ('\u0fb9', &['\u0f90', '\u0fb5']), ('\u1026',
- &['\u1025', '\u102e']), ('\u1b06', &['\u1b05', '\u1b35']), ('\u1b08', &['\u1b07',
- '\u1b35']), ('\u1b0a', &['\u1b09', '\u1b35']), ('\u1b0c', &['\u1b0b', '\u1b35']), ('\u1b0e',
- &['\u1b0d', '\u1b35']), ('\u1b12', &['\u1b11', '\u1b35']), ('\u1b3b', &['\u1b3a',
- '\u1b35']), ('\u1b3d', &['\u1b3c', '\u1b35']), ('\u1b40', &['\u1b3e', '\u1b35']), ('\u1b41',
- &['\u1b3f', '\u1b35']), ('\u1b43', &['\u1b42', '\u1b35']), ('\u1e00', &['\x41', '\u0325']),
- ('\u1e01', &['\x61', '\u0325']), ('\u1e02', &['\x42', '\u0307']), ('\u1e03', &['\x62',
- '\u0307']), ('\u1e04', &['\x42', '\u0323']), ('\u1e05', &['\x62', '\u0323']), ('\u1e06',
- &['\x42', '\u0331']), ('\u1e07', &['\x62', '\u0331']), ('\u1e08', &['\xc7', '\u0301']),
- ('\u1e09', &['\xe7', '\u0301']), ('\u1e0a', &['\x44', '\u0307']), ('\u1e0b', &['\x64',
- '\u0307']), ('\u1e0c', &['\x44', '\u0323']), ('\u1e0d', &['\x64', '\u0323']), ('\u1e0e',
- &['\x44', '\u0331']), ('\u1e0f', &['\x64', '\u0331']), ('\u1e10', &['\x44', '\u0327']),
- ('\u1e11', &['\x64', '\u0327']), ('\u1e12', &['\x44', '\u032d']), ('\u1e13', &['\x64',
- '\u032d']), ('\u1e14', &['\u0112', '\u0300']), ('\u1e15', &['\u0113', '\u0300']), ('\u1e16',
- &['\u0112', '\u0301']), ('\u1e17', &['\u0113', '\u0301']), ('\u1e18', &['\x45', '\u032d']),
- ('\u1e19', &['\x65', '\u032d']), ('\u1e1a', &['\x45', '\u0330']), ('\u1e1b', &['\x65',
- '\u0330']), ('\u1e1c', &['\u0228', '\u0306']), ('\u1e1d', &['\u0229', '\u0306']), ('\u1e1e',
- &['\x46', '\u0307']), ('\u1e1f', &['\x66', '\u0307']), ('\u1e20', &['\x47', '\u0304']),
- ('\u1e21', &['\x67', '\u0304']), ('\u1e22', &['\x48', '\u0307']), ('\u1e23', &['\x68',
- '\u0307']), ('\u1e24', &['\x48', '\u0323']), ('\u1e25', &['\x68', '\u0323']), ('\u1e26',
- &['\x48', '\u0308']), ('\u1e27', &['\x68', '\u0308']), ('\u1e28', &['\x48', '\u0327']),
- ('\u1e29', &['\x68', '\u0327']), ('\u1e2a', &['\x48', '\u032e']), ('\u1e2b', &['\x68',
- '\u032e']), ('\u1e2c', &['\x49', '\u0330']), ('\u1e2d', &['\x69', '\u0330']), ('\u1e2e',
- &['\xcf', '\u0301']), ('\u1e2f', &['\xef', '\u0301']), ('\u1e30', &['\x4b', '\u0301']),
- ('\u1e31', &['\x6b', '\u0301']), ('\u1e32', &['\x4b', '\u0323']), ('\u1e33', &['\x6b',
- '\u0323']), ('\u1e34', &['\x4b', '\u0331']), ('\u1e35', &['\x6b', '\u0331']), ('\u1e36',
- &['\x4c', '\u0323']), ('\u1e37', &['\x6c', '\u0323']), ('\u1e38', &['\u1e36', '\u0304']),
- ('\u1e39', &['\u1e37', '\u0304']), ('\u1e3a', &['\x4c', '\u0331']), ('\u1e3b', &['\x6c',
- '\u0331']), ('\u1e3c', &['\x4c', '\u032d']), ('\u1e3d', &['\x6c', '\u032d']), ('\u1e3e',
- &['\x4d', '\u0301']), ('\u1e3f', &['\x6d', '\u0301']), ('\u1e40', &['\x4d', '\u0307']),
- ('\u1e41', &['\x6d', '\u0307']), ('\u1e42', &['\x4d', '\u0323']), ('\u1e43', &['\x6d',
- '\u0323']), ('\u1e44', &['\x4e', '\u0307']), ('\u1e45', &['\x6e', '\u0307']), ('\u1e46',
- &['\x4e', '\u0323']), ('\u1e47', &['\x6e', '\u0323']), ('\u1e48', &['\x4e', '\u0331']),
- ('\u1e49', &['\x6e', '\u0331']), ('\u1e4a', &['\x4e', '\u032d']), ('\u1e4b', &['\x6e',
- '\u032d']), ('\u1e4c', &['\xd5', '\u0301']), ('\u1e4d', &['\xf5', '\u0301']), ('\u1e4e',
- &['\xd5', '\u0308']), ('\u1e4f', &['\xf5', '\u0308']), ('\u1e50', &['\u014c', '\u0300']),
- ('\u1e51', &['\u014d', '\u0300']), ('\u1e52', &['\u014c', '\u0301']), ('\u1e53', &['\u014d',
- '\u0301']), ('\u1e54', &['\x50', '\u0301']), ('\u1e55', &['\x70', '\u0301']), ('\u1e56',
- &['\x50', '\u0307']), ('\u1e57', &['\x70', '\u0307']), ('\u1e58', &['\x52', '\u0307']),
- ('\u1e59', &['\x72', '\u0307']), ('\u1e5a', &['\x52', '\u0323']), ('\u1e5b', &['\x72',
- '\u0323']), ('\u1e5c', &['\u1e5a', '\u0304']), ('\u1e5d', &['\u1e5b', '\u0304']), ('\u1e5e',
- &['\x52', '\u0331']), ('\u1e5f', &['\x72', '\u0331']), ('\u1e60', &['\x53', '\u0307']),
- ('\u1e61', &['\x73', '\u0307']), ('\u1e62', &['\x53', '\u0323']), ('\u1e63', &['\x73',
- '\u0323']), ('\u1e64', &['\u015a', '\u0307']), ('\u1e65', &['\u015b', '\u0307']), ('\u1e66',
- &['\u0160', '\u0307']), ('\u1e67', &['\u0161', '\u0307']), ('\u1e68', &['\u1e62',
- '\u0307']), ('\u1e69', &['\u1e63', '\u0307']), ('\u1e6a', &['\x54', '\u0307']), ('\u1e6b',
- &['\x74', '\u0307']), ('\u1e6c', &['\x54', '\u0323']), ('\u1e6d', &['\x74', '\u0323']),
- ('\u1e6e', &['\x54', '\u0331']), ('\u1e6f', &['\x74', '\u0331']), ('\u1e70', &['\x54',
- '\u032d']), ('\u1e71', &['\x74', '\u032d']), ('\u1e72', &['\x55', '\u0324']), ('\u1e73',
- &['\x75', '\u0324']), ('\u1e74', &['\x55', '\u0330']), ('\u1e75', &['\x75', '\u0330']),
- ('\u1e76', &['\x55', '\u032d']), ('\u1e77', &['\x75', '\u032d']), ('\u1e78', &['\u0168',
- '\u0301']), ('\u1e79', &['\u0169', '\u0301']), ('\u1e7a', &['\u016a', '\u0308']), ('\u1e7b',
- &['\u016b', '\u0308']), ('\u1e7c', &['\x56', '\u0303']), ('\u1e7d', &['\x76', '\u0303']),
- ('\u1e7e', &['\x56', '\u0323']), ('\u1e7f', &['\x76', '\u0323']), ('\u1e80', &['\x57',
- '\u0300']), ('\u1e81', &['\x77', '\u0300']), ('\u1e82', &['\x57', '\u0301']), ('\u1e83',
- &['\x77', '\u0301']), ('\u1e84', &['\x57', '\u0308']), ('\u1e85', &['\x77', '\u0308']),
- ('\u1e86', &['\x57', '\u0307']), ('\u1e87', &['\x77', '\u0307']), ('\u1e88', &['\x57',
- '\u0323']), ('\u1e89', &['\x77', '\u0323']), ('\u1e8a', &['\x58', '\u0307']), ('\u1e8b',
- &['\x78', '\u0307']), ('\u1e8c', &['\x58', '\u0308']), ('\u1e8d', &['\x78', '\u0308']),
- ('\u1e8e', &['\x59', '\u0307']), ('\u1e8f', &['\x79', '\u0307']), ('\u1e90', &['\x5a',
- '\u0302']), ('\u1e91', &['\x7a', '\u0302']), ('\u1e92', &['\x5a', '\u0323']), ('\u1e93',
- &['\x7a', '\u0323']), ('\u1e94', &['\x5a', '\u0331']), ('\u1e95', &['\x7a', '\u0331']),
- ('\u1e96', &['\x68', '\u0331']), ('\u1e97', &['\x74', '\u0308']), ('\u1e98', &['\x77',
- '\u030a']), ('\u1e99', &['\x79', '\u030a']), ('\u1e9b', &['\u017f', '\u0307']), ('\u1ea0',
- &['\x41', '\u0323']), ('\u1ea1', &['\x61', '\u0323']), ('\u1ea2', &['\x41', '\u0309']),
- ('\u1ea3', &['\x61', '\u0309']), ('\u1ea4', &['\xc2', '\u0301']), ('\u1ea5', &['\xe2',
- '\u0301']), ('\u1ea6', &['\xc2', '\u0300']), ('\u1ea7', &['\xe2', '\u0300']), ('\u1ea8',
- &['\xc2', '\u0309']), ('\u1ea9', &['\xe2', '\u0309']), ('\u1eaa', &['\xc2', '\u0303']),
- ('\u1eab', &['\xe2', '\u0303']), ('\u1eac', &['\u1ea0', '\u0302']), ('\u1ead', &['\u1ea1',
- '\u0302']), ('\u1eae', &['\u0102', '\u0301']), ('\u1eaf', &['\u0103', '\u0301']), ('\u1eb0',
- &['\u0102', '\u0300']), ('\u1eb1', &['\u0103', '\u0300']), ('\u1eb2', &['\u0102',
- '\u0309']), ('\u1eb3', &['\u0103', '\u0309']), ('\u1eb4', &['\u0102', '\u0303']), ('\u1eb5',
- &['\u0103', '\u0303']), ('\u1eb6', &['\u1ea0', '\u0306']), ('\u1eb7', &['\u1ea1',
- '\u0306']), ('\u1eb8', &['\x45', '\u0323']), ('\u1eb9', &['\x65', '\u0323']), ('\u1eba',
- &['\x45', '\u0309']), ('\u1ebb', &['\x65', '\u0309']), ('\u1ebc', &['\x45', '\u0303']),
- ('\u1ebd', &['\x65', '\u0303']), ('\u1ebe', &['\xca', '\u0301']), ('\u1ebf', &['\xea',
- '\u0301']), ('\u1ec0', &['\xca', '\u0300']), ('\u1ec1', &['\xea', '\u0300']), ('\u1ec2',
- &['\xca', '\u0309']), ('\u1ec3', &['\xea', '\u0309']), ('\u1ec4', &['\xca', '\u0303']),
- ('\u1ec5', &['\xea', '\u0303']), ('\u1ec6', &['\u1eb8', '\u0302']), ('\u1ec7', &['\u1eb9',
- '\u0302']), ('\u1ec8', &['\x49', '\u0309']), ('\u1ec9', &['\x69', '\u0309']), ('\u1eca',
- &['\x49', '\u0323']), ('\u1ecb', &['\x69', '\u0323']), ('\u1ecc', &['\x4f', '\u0323']),
- ('\u1ecd', &['\x6f', '\u0323']), ('\u1ece', &['\x4f', '\u0309']), ('\u1ecf', &['\x6f',
- '\u0309']), ('\u1ed0', &['\xd4', '\u0301']), ('\u1ed1', &['\xf4', '\u0301']), ('\u1ed2',
- &['\xd4', '\u0300']), ('\u1ed3', &['\xf4', '\u0300']), ('\u1ed4', &['\xd4', '\u0309']),
- ('\u1ed5', &['\xf4', '\u0309']), ('\u1ed6', &['\xd4', '\u0303']), ('\u1ed7', &['\xf4',
- '\u0303']), ('\u1ed8', &['\u1ecc', '\u0302']), ('\u1ed9', &['\u1ecd', '\u0302']), ('\u1eda',
- &['\u01a0', '\u0301']), ('\u1edb', &['\u01a1', '\u0301']), ('\u1edc', &['\u01a0',
- '\u0300']), ('\u1edd', &['\u01a1', '\u0300']), ('\u1ede', &['\u01a0', '\u0309']), ('\u1edf',
- &['\u01a1', '\u0309']), ('\u1ee0', &['\u01a0', '\u0303']), ('\u1ee1', &['\u01a1',
- '\u0303']), ('\u1ee2', &['\u01a0', '\u0323']), ('\u1ee3', &['\u01a1', '\u0323']), ('\u1ee4',
- &['\x55', '\u0323']), ('\u1ee5', &['\x75', '\u0323']), ('\u1ee6', &['\x55', '\u0309']),
- ('\u1ee7', &['\x75', '\u0309']), ('\u1ee8', &['\u01af', '\u0301']), ('\u1ee9', &['\u01b0',
- '\u0301']), ('\u1eea', &['\u01af', '\u0300']), ('\u1eeb', &['\u01b0', '\u0300']), ('\u1eec',
- &['\u01af', '\u0309']), ('\u1eed', &['\u01b0', '\u0309']), ('\u1eee', &['\u01af',
- '\u0303']), ('\u1eef', &['\u01b0', '\u0303']), ('\u1ef0', &['\u01af', '\u0323']), ('\u1ef1',
- &['\u01b0', '\u0323']), ('\u1ef2', &['\x59', '\u0300']), ('\u1ef3', &['\x79', '\u0300']),
- ('\u1ef4', &['\x59', '\u0323']), ('\u1ef5', &['\x79', '\u0323']), ('\u1ef6', &['\x59',
- '\u0309']), ('\u1ef7', &['\x79', '\u0309']), ('\u1ef8', &['\x59', '\u0303']), ('\u1ef9',
- &['\x79', '\u0303']), ('\u1f00', &['\u03b1', '\u0313']), ('\u1f01', &['\u03b1', '\u0314']),
- ('\u1f02', &['\u1f00', '\u0300']), ('\u1f03', &['\u1f01', '\u0300']), ('\u1f04', &['\u1f00',
- '\u0301']), ('\u1f05', &['\u1f01', '\u0301']), ('\u1f06', &['\u1f00', '\u0342']), ('\u1f07',
- &['\u1f01', '\u0342']), ('\u1f08', &['\u0391', '\u0313']), ('\u1f09', &['\u0391',
- '\u0314']), ('\u1f0a', &['\u1f08', '\u0300']), ('\u1f0b', &['\u1f09', '\u0300']), ('\u1f0c',
- &['\u1f08', '\u0301']), ('\u1f0d', &['\u1f09', '\u0301']), ('\u1f0e', &['\u1f08',
- '\u0342']), ('\u1f0f', &['\u1f09', '\u0342']), ('\u1f10', &['\u03b5', '\u0313']), ('\u1f11',
- &['\u03b5', '\u0314']), ('\u1f12', &['\u1f10', '\u0300']), ('\u1f13', &['\u1f11',
- '\u0300']), ('\u1f14', &['\u1f10', '\u0301']), ('\u1f15', &['\u1f11', '\u0301']), ('\u1f18',
- &['\u0395', '\u0313']), ('\u1f19', &['\u0395', '\u0314']), ('\u1f1a', &['\u1f18',
- '\u0300']), ('\u1f1b', &['\u1f19', '\u0300']), ('\u1f1c', &['\u1f18', '\u0301']), ('\u1f1d',
- &['\u1f19', '\u0301']), ('\u1f20', &['\u03b7', '\u0313']), ('\u1f21', &['\u03b7',
- '\u0314']), ('\u1f22', &['\u1f20', '\u0300']), ('\u1f23', &['\u1f21', '\u0300']), ('\u1f24',
- &['\u1f20', '\u0301']), ('\u1f25', &['\u1f21', '\u0301']), ('\u1f26', &['\u1f20',
- '\u0342']), ('\u1f27', &['\u1f21', '\u0342']), ('\u1f28', &['\u0397', '\u0313']), ('\u1f29',
- &['\u0397', '\u0314']), ('\u1f2a', &['\u1f28', '\u0300']), ('\u1f2b', &['\u1f29',
- '\u0300']), ('\u1f2c', &['\u1f28', '\u0301']), ('\u1f2d', &['\u1f29', '\u0301']), ('\u1f2e',
- &['\u1f28', '\u0342']), ('\u1f2f', &['\u1f29', '\u0342']), ('\u1f30', &['\u03b9',
- '\u0313']), ('\u1f31', &['\u03b9', '\u0314']), ('\u1f32', &['\u1f30', '\u0300']), ('\u1f33',
- &['\u1f31', '\u0300']), ('\u1f34', &['\u1f30', '\u0301']), ('\u1f35', &['\u1f31',
- '\u0301']), ('\u1f36', &['\u1f30', '\u0342']), ('\u1f37', &['\u1f31', '\u0342']), ('\u1f38',
- &['\u0399', '\u0313']), ('\u1f39', &['\u0399', '\u0314']), ('\u1f3a', &['\u1f38',
- '\u0300']), ('\u1f3b', &['\u1f39', '\u0300']), ('\u1f3c', &['\u1f38', '\u0301']), ('\u1f3d',
- &['\u1f39', '\u0301']), ('\u1f3e', &['\u1f38', '\u0342']), ('\u1f3f', &['\u1f39',
- '\u0342']), ('\u1f40', &['\u03bf', '\u0313']), ('\u1f41', &['\u03bf', '\u0314']), ('\u1f42',
- &['\u1f40', '\u0300']), ('\u1f43', &['\u1f41', '\u0300']), ('\u1f44', &['\u1f40',
- '\u0301']), ('\u1f45', &['\u1f41', '\u0301']), ('\u1f48', &['\u039f', '\u0313']), ('\u1f49',
- &['\u039f', '\u0314']), ('\u1f4a', &['\u1f48', '\u0300']), ('\u1f4b', &['\u1f49',
- '\u0300']), ('\u1f4c', &['\u1f48', '\u0301']), ('\u1f4d', &['\u1f49', '\u0301']), ('\u1f50',
- &['\u03c5', '\u0313']), ('\u1f51', &['\u03c5', '\u0314']), ('\u1f52', &['\u1f50',
- '\u0300']), ('\u1f53', &['\u1f51', '\u0300']), ('\u1f54', &['\u1f50', '\u0301']), ('\u1f55',
- &['\u1f51', '\u0301']), ('\u1f56', &['\u1f50', '\u0342']), ('\u1f57', &['\u1f51',
- '\u0342']), ('\u1f59', &['\u03a5', '\u0314']), ('\u1f5b', &['\u1f59', '\u0300']), ('\u1f5d',
- &['\u1f59', '\u0301']), ('\u1f5f', &['\u1f59', '\u0342']), ('\u1f60', &['\u03c9',
- '\u0313']), ('\u1f61', &['\u03c9', '\u0314']), ('\u1f62', &['\u1f60', '\u0300']), ('\u1f63',
- &['\u1f61', '\u0300']), ('\u1f64', &['\u1f60', '\u0301']), ('\u1f65', &['\u1f61',
- '\u0301']), ('\u1f66', &['\u1f60', '\u0342']), ('\u1f67', &['\u1f61', '\u0342']), ('\u1f68',
- &['\u03a9', '\u0313']), ('\u1f69', &['\u03a9', '\u0314']), ('\u1f6a', &['\u1f68',
- '\u0300']), ('\u1f6b', &['\u1f69', '\u0300']), ('\u1f6c', &['\u1f68', '\u0301']), ('\u1f6d',
- &['\u1f69', '\u0301']), ('\u1f6e', &['\u1f68', '\u0342']), ('\u1f6f', &['\u1f69',
- '\u0342']), ('\u1f70', &['\u03b1', '\u0300']), ('\u1f71', &['\u03ac']), ('\u1f72',
- &['\u03b5', '\u0300']), ('\u1f73', &['\u03ad']), ('\u1f74', &['\u03b7', '\u0300']),
- ('\u1f75', &['\u03ae']), ('\u1f76', &['\u03b9', '\u0300']), ('\u1f77', &['\u03af']),
- ('\u1f78', &['\u03bf', '\u0300']), ('\u1f79', &['\u03cc']), ('\u1f7a', &['\u03c5',
- '\u0300']), ('\u1f7b', &['\u03cd']), ('\u1f7c', &['\u03c9', '\u0300']), ('\u1f7d',
- &['\u03ce']), ('\u1f80', &['\u1f00', '\u0345']), ('\u1f81', &['\u1f01', '\u0345']),
- ('\u1f82', &['\u1f02', '\u0345']), ('\u1f83', &['\u1f03', '\u0345']), ('\u1f84', &['\u1f04',
- '\u0345']), ('\u1f85', &['\u1f05', '\u0345']), ('\u1f86', &['\u1f06', '\u0345']), ('\u1f87',
- &['\u1f07', '\u0345']), ('\u1f88', &['\u1f08', '\u0345']), ('\u1f89', &['\u1f09',
- '\u0345']), ('\u1f8a', &['\u1f0a', '\u0345']), ('\u1f8b', &['\u1f0b', '\u0345']), ('\u1f8c',
- &['\u1f0c', '\u0345']), ('\u1f8d', &['\u1f0d', '\u0345']), ('\u1f8e', &['\u1f0e',
- '\u0345']), ('\u1f8f', &['\u1f0f', '\u0345']), ('\u1f90', &['\u1f20', '\u0345']), ('\u1f91',
- &['\u1f21', '\u0345']), ('\u1f92', &['\u1f22', '\u0345']), ('\u1f93', &['\u1f23',
- '\u0345']), ('\u1f94', &['\u1f24', '\u0345']), ('\u1f95', &['\u1f25', '\u0345']), ('\u1f96',
- &['\u1f26', '\u0345']), ('\u1f97', &['\u1f27', '\u0345']), ('\u1f98', &['\u1f28',
- '\u0345']), ('\u1f99', &['\u1f29', '\u0345']), ('\u1f9a', &['\u1f2a', '\u0345']), ('\u1f9b',
- &['\u1f2b', '\u0345']), ('\u1f9c', &['\u1f2c', '\u0345']), ('\u1f9d', &['\u1f2d',
- '\u0345']), ('\u1f9e', &['\u1f2e', '\u0345']), ('\u1f9f', &['\u1f2f', '\u0345']), ('\u1fa0',
- &['\u1f60', '\u0345']), ('\u1fa1', &['\u1f61', '\u0345']), ('\u1fa2', &['\u1f62',
- '\u0345']), ('\u1fa3', &['\u1f63', '\u0345']), ('\u1fa4', &['\u1f64', '\u0345']), ('\u1fa5',
- &['\u1f65', '\u0345']), ('\u1fa6', &['\u1f66', '\u0345']), ('\u1fa7', &['\u1f67',
- '\u0345']), ('\u1fa8', &['\u1f68', '\u0345']), ('\u1fa9', &['\u1f69', '\u0345']), ('\u1faa',
- &['\u1f6a', '\u0345']), ('\u1fab', &['\u1f6b', '\u0345']), ('\u1fac', &['\u1f6c',
- '\u0345']), ('\u1fad', &['\u1f6d', '\u0345']), ('\u1fae', &['\u1f6e', '\u0345']), ('\u1faf',
- &['\u1f6f', '\u0345']), ('\u1fb0', &['\u03b1', '\u0306']), ('\u1fb1', &['\u03b1',
- '\u0304']), ('\u1fb2', &['\u1f70', '\u0345']), ('\u1fb3', &['\u03b1', '\u0345']), ('\u1fb4',
- &['\u03ac', '\u0345']), ('\u1fb6', &['\u03b1', '\u0342']), ('\u1fb7', &['\u1fb6',
- '\u0345']), ('\u1fb8', &['\u0391', '\u0306']), ('\u1fb9', &['\u0391', '\u0304']), ('\u1fba',
- &['\u0391', '\u0300']), ('\u1fbb', &['\u0386']), ('\u1fbc', &['\u0391', '\u0345']),
- ('\u1fbe', &['\u03b9']), ('\u1fc1', &['\xa8', '\u0342']), ('\u1fc2', &['\u1f74', '\u0345']),
- ('\u1fc3', &['\u03b7', '\u0345']), ('\u1fc4', &['\u03ae', '\u0345']), ('\u1fc6', &['\u03b7',
- '\u0342']), ('\u1fc7', &['\u1fc6', '\u0345']), ('\u1fc8', &['\u0395', '\u0300']), ('\u1fc9',
- &['\u0388']), ('\u1fca', &['\u0397', '\u0300']), ('\u1fcb', &['\u0389']), ('\u1fcc',
- &['\u0397', '\u0345']), ('\u1fcd', &['\u1fbf', '\u0300']), ('\u1fce', &['\u1fbf',
- '\u0301']), ('\u1fcf', &['\u1fbf', '\u0342']), ('\u1fd0', &['\u03b9', '\u0306']), ('\u1fd1',
- &['\u03b9', '\u0304']), ('\u1fd2', &['\u03ca', '\u0300']), ('\u1fd3', &['\u0390']),
- ('\u1fd6', &['\u03b9', '\u0342']), ('\u1fd7', &['\u03ca', '\u0342']), ('\u1fd8', &['\u0399',
- '\u0306']), ('\u1fd9', &['\u0399', '\u0304']), ('\u1fda', &['\u0399', '\u0300']), ('\u1fdb',
- &['\u038a']), ('\u1fdd', &['\u1ffe', '\u0300']), ('\u1fde', &['\u1ffe', '\u0301']),
- ('\u1fdf', &['\u1ffe', '\u0342']), ('\u1fe0', &['\u03c5', '\u0306']), ('\u1fe1', &['\u03c5',
- '\u0304']), ('\u1fe2', &['\u03cb', '\u0300']), ('\u1fe3', &['\u03b0']), ('\u1fe4',
- &['\u03c1', '\u0313']), ('\u1fe5', &['\u03c1', '\u0314']), ('\u1fe6', &['\u03c5',
- '\u0342']), ('\u1fe7', &['\u03cb', '\u0342']), ('\u1fe8', &['\u03a5', '\u0306']), ('\u1fe9',
- &['\u03a5', '\u0304']), ('\u1fea', &['\u03a5', '\u0300']), ('\u1feb', &['\u038e']),
- ('\u1fec', &['\u03a1', '\u0314']), ('\u1fed', &['\xa8', '\u0300']), ('\u1fee', &['\u0385']),
- ('\u1fef', &['\x60']), ('\u1ff2', &['\u1f7c', '\u0345']), ('\u1ff3', &['\u03c9', '\u0345']),
- ('\u1ff4', &['\u03ce', '\u0345']), ('\u1ff6', &['\u03c9', '\u0342']), ('\u1ff7', &['\u1ff6',
- '\u0345']), ('\u1ff8', &['\u039f', '\u0300']), ('\u1ff9', &['\u038c']), ('\u1ffa',
- &['\u03a9', '\u0300']), ('\u1ffb', &['\u038f']), ('\u1ffc', &['\u03a9', '\u0345']),
- ('\u1ffd', &['\xb4']), ('\u2000', &['\u2002']), ('\u2001', &['\u2003']), ('\u2126',
- &['\u03a9']), ('\u212a', &['\x4b']), ('\u212b', &['\xc5']), ('\u219a', &['\u2190',
- '\u0338']), ('\u219b', &['\u2192', '\u0338']), ('\u21ae', &['\u2194', '\u0338']), ('\u21cd',
- &['\u21d0', '\u0338']), ('\u21ce', &['\u21d4', '\u0338']), ('\u21cf', &['\u21d2',
- '\u0338']), ('\u2204', &['\u2203', '\u0338']), ('\u2209', &['\u2208', '\u0338']), ('\u220c',
- &['\u220b', '\u0338']), ('\u2224', &['\u2223', '\u0338']), ('\u2226', &['\u2225',
- '\u0338']), ('\u2241', &['\u223c', '\u0338']), ('\u2244', &['\u2243', '\u0338']), ('\u2247',
- &['\u2245', '\u0338']), ('\u2249', &['\u2248', '\u0338']), ('\u2260', &['\x3d', '\u0338']),
- ('\u2262', &['\u2261', '\u0338']), ('\u226d', &['\u224d', '\u0338']), ('\u226e', &['\x3c',
- '\u0338']), ('\u226f', &['\x3e', '\u0338']), ('\u2270', &['\u2264', '\u0338']), ('\u2271',
- &['\u2265', '\u0338']), ('\u2274', &['\u2272', '\u0338']), ('\u2275', &['\u2273',
- '\u0338']), ('\u2278', &['\u2276', '\u0338']), ('\u2279', &['\u2277', '\u0338']), ('\u2280',
- &['\u227a', '\u0338']), ('\u2281', &['\u227b', '\u0338']), ('\u2284', &['\u2282',
- '\u0338']), ('\u2285', &['\u2283', '\u0338']), ('\u2288', &['\u2286', '\u0338']), ('\u2289',
- &['\u2287', '\u0338']), ('\u22ac', &['\u22a2', '\u0338']), ('\u22ad', &['\u22a8',
- '\u0338']), ('\u22ae', &['\u22a9', '\u0338']), ('\u22af', &['\u22ab', '\u0338']), ('\u22e0',
- &['\u227c', '\u0338']), ('\u22e1', &['\u227d', '\u0338']), ('\u22e2', &['\u2291',
- '\u0338']), ('\u22e3', &['\u2292', '\u0338']), ('\u22ea', &['\u22b2', '\u0338']), ('\u22eb',
- &['\u22b3', '\u0338']), ('\u22ec', &['\u22b4', '\u0338']), ('\u22ed', &['\u22b5',
- '\u0338']), ('\u2329', &['\u3008']), ('\u232a', &['\u3009']), ('\u2adc', &['\u2add',
- '\u0338']), ('\u304c', &['\u304b', '\u3099']), ('\u304e', &['\u304d', '\u3099']), ('\u3050',
- &['\u304f', '\u3099']), ('\u3052', &['\u3051', '\u3099']), ('\u3054', &['\u3053',
- '\u3099']), ('\u3056', &['\u3055', '\u3099']), ('\u3058', &['\u3057', '\u3099']), ('\u305a',
- &['\u3059', '\u3099']), ('\u305c', &['\u305b', '\u3099']), ('\u305e', &['\u305d',
- '\u3099']), ('\u3060', &['\u305f', '\u3099']), ('\u3062', &['\u3061', '\u3099']), ('\u3065',
- &['\u3064', '\u3099']), ('\u3067', &['\u3066', '\u3099']), ('\u3069', &['\u3068',
- '\u3099']), ('\u3070', &['\u306f', '\u3099']), ('\u3071', &['\u306f', '\u309a']), ('\u3073',
- &['\u3072', '\u3099']), ('\u3074', &['\u3072', '\u309a']), ('\u3076', &['\u3075',
- '\u3099']), ('\u3077', &['\u3075', '\u309a']), ('\u3079', &['\u3078', '\u3099']), ('\u307a',
- &['\u3078', '\u309a']), ('\u307c', &['\u307b', '\u3099']), ('\u307d', &['\u307b',
- '\u309a']), ('\u3094', &['\u3046', '\u3099']), ('\u309e', &['\u309d', '\u3099']), ('\u30ac',
- &['\u30ab', '\u3099']), ('\u30ae', &['\u30ad', '\u3099']), ('\u30b0', &['\u30af',
- '\u3099']), ('\u30b2', &['\u30b1', '\u3099']), ('\u30b4', &['\u30b3', '\u3099']), ('\u30b6',
- &['\u30b5', '\u3099']), ('\u30b8', &['\u30b7', '\u3099']), ('\u30ba', &['\u30b9',
- '\u3099']), ('\u30bc', &['\u30bb', '\u3099']), ('\u30be', &['\u30bd', '\u3099']), ('\u30c0',
- &['\u30bf', '\u3099']), ('\u30c2', &['\u30c1', '\u3099']), ('\u30c5', &['\u30c4',
- '\u3099']), ('\u30c7', &['\u30c6', '\u3099']), ('\u30c9', &['\u30c8', '\u3099']), ('\u30d0',
- &['\u30cf', '\u3099']), ('\u30d1', &['\u30cf', '\u309a']), ('\u30d3', &['\u30d2',
- '\u3099']), ('\u30d4', &['\u30d2', '\u309a']), ('\u30d6', &['\u30d5', '\u3099']), ('\u30d7',
- &['\u30d5', '\u309a']), ('\u30d9', &['\u30d8', '\u3099']), ('\u30da', &['\u30d8',
- '\u309a']), ('\u30dc', &['\u30db', '\u3099']), ('\u30dd', &['\u30db', '\u309a']), ('\u30f4',
- &['\u30a6', '\u3099']), ('\u30f7', &['\u30ef', '\u3099']), ('\u30f8', &['\u30f0',
- '\u3099']), ('\u30f9', &['\u30f1', '\u3099']), ('\u30fa', &['\u30f2', '\u3099']), ('\u30fe',
- &['\u30fd', '\u3099']), ('\uf900', &['\u8c48']), ('\uf901', &['\u66f4']), ('\uf902',
- &['\u8eca']), ('\uf903', &['\u8cc8']), ('\uf904', &['\u6ed1']), ('\uf905', &['\u4e32']),
- ('\uf906', &['\u53e5']), ('\uf907', &['\u9f9c']), ('\uf908', &['\u9f9c']), ('\uf909',
- &['\u5951']), ('\uf90a', &['\u91d1']), ('\uf90b', &['\u5587']), ('\uf90c', &['\u5948']),
- ('\uf90d', &['\u61f6']), ('\uf90e', &['\u7669']), ('\uf90f', &['\u7f85']), ('\uf910',
- &['\u863f']), ('\uf911', &['\u87ba']), ('\uf912', &['\u88f8']), ('\uf913', &['\u908f']),
- ('\uf914', &['\u6a02']), ('\uf915', &['\u6d1b']), ('\uf916', &['\u70d9']), ('\uf917',
- &['\u73de']), ('\uf918', &['\u843d']), ('\uf919', &['\u916a']), ('\uf91a', &['\u99f1']),
- ('\uf91b', &['\u4e82']), ('\uf91c', &['\u5375']), ('\uf91d', &['\u6b04']), ('\uf91e',
- &['\u721b']), ('\uf91f', &['\u862d']), ('\uf920', &['\u9e1e']), ('\uf921', &['\u5d50']),
- ('\uf922', &['\u6feb']), ('\uf923', &['\u85cd']), ('\uf924', &['\u8964']), ('\uf925',
- &['\u62c9']), ('\uf926', &['\u81d8']), ('\uf927', &['\u881f']), ('\uf928', &['\u5eca']),
- ('\uf929', &['\u6717']), ('\uf92a', &['\u6d6a']), ('\uf92b', &['\u72fc']), ('\uf92c',
- &['\u90ce']), ('\uf92d', &['\u4f86']), ('\uf92e', &['\u51b7']), ('\uf92f', &['\u52de']),
- ('\uf930', &['\u64c4']), ('\uf931', &['\u6ad3']), ('\uf932', &['\u7210']), ('\uf933',
- &['\u76e7']), ('\uf934', &['\u8001']), ('\uf935', &['\u8606']), ('\uf936', &['\u865c']),
- ('\uf937', &['\u8def']), ('\uf938', &['\u9732']), ('\uf939', &['\u9b6f']), ('\uf93a',
- &['\u9dfa']), ('\uf93b', &['\u788c']), ('\uf93c', &['\u797f']), ('\uf93d', &['\u7da0']),
- ('\uf93e', &['\u83c9']), ('\uf93f', &['\u9304']), ('\uf940', &['\u9e7f']), ('\uf941',
- &['\u8ad6']), ('\uf942', &['\u58df']), ('\uf943', &['\u5f04']), ('\uf944', &['\u7c60']),
- ('\uf945', &['\u807e']), ('\uf946', &['\u7262']), ('\uf947', &['\u78ca']), ('\uf948',
- &['\u8cc2']), ('\uf949', &['\u96f7']), ('\uf94a', &['\u58d8']), ('\uf94b', &['\u5c62']),
- ('\uf94c', &['\u6a13']), ('\uf94d', &['\u6dda']), ('\uf94e', &['\u6f0f']), ('\uf94f',
- &['\u7d2f']), ('\uf950', &['\u7e37']), ('\uf951', &['\u964b']), ('\uf952', &['\u52d2']),
- ('\uf953', &['\u808b']), ('\uf954', &['\u51dc']), ('\uf955', &['\u51cc']), ('\uf956',
- &['\u7a1c']), ('\uf957', &['\u7dbe']), ('\uf958', &['\u83f1']), ('\uf959', &['\u9675']),
- ('\uf95a', &['\u8b80']), ('\uf95b', &['\u62cf']), ('\uf95c', &['\u6a02']), ('\uf95d',
- &['\u8afe']), ('\uf95e', &['\u4e39']), ('\uf95f', &['\u5be7']), ('\uf960', &['\u6012']),
- ('\uf961', &['\u7387']), ('\uf962', &['\u7570']), ('\uf963', &['\u5317']), ('\uf964',
- &['\u78fb']), ('\uf965', &['\u4fbf']), ('\uf966', &['\u5fa9']), ('\uf967', &['\u4e0d']),
- ('\uf968', &['\u6ccc']), ('\uf969', &['\u6578']), ('\uf96a', &['\u7d22']), ('\uf96b',
- &['\u53c3']), ('\uf96c', &['\u585e']), ('\uf96d', &['\u7701']), ('\uf96e', &['\u8449']),
- ('\uf96f', &['\u8aaa']), ('\uf970', &['\u6bba']), ('\uf971', &['\u8fb0']), ('\uf972',
- &['\u6c88']), ('\uf973', &['\u62fe']), ('\uf974', &['\u82e5']), ('\uf975', &['\u63a0']),
- ('\uf976', &['\u7565']), ('\uf977', &['\u4eae']), ('\uf978', &['\u5169']), ('\uf979',
- &['\u51c9']), ('\uf97a', &['\u6881']), ('\uf97b', &['\u7ce7']), ('\uf97c', &['\u826f']),
- ('\uf97d', &['\u8ad2']), ('\uf97e', &['\u91cf']), ('\uf97f', &['\u52f5']), ('\uf980',
- &['\u5442']), ('\uf981', &['\u5973']), ('\uf982', &['\u5eec']), ('\uf983', &['\u65c5']),
- ('\uf984', &['\u6ffe']), ('\uf985', &['\u792a']), ('\uf986', &['\u95ad']), ('\uf987',
- &['\u9a6a']), ('\uf988', &['\u9e97']), ('\uf989', &['\u9ece']), ('\uf98a', &['\u529b']),
- ('\uf98b', &['\u66c6']), ('\uf98c', &['\u6b77']), ('\uf98d', &['\u8f62']), ('\uf98e',
- &['\u5e74']), ('\uf98f', &['\u6190']), ('\uf990', &['\u6200']), ('\uf991', &['\u649a']),
- ('\uf992', &['\u6f23']), ('\uf993', &['\u7149']), ('\uf994', &['\u7489']), ('\uf995',
- &['\u79ca']), ('\uf996', &['\u7df4']), ('\uf997', &['\u806f']), ('\uf998', &['\u8f26']),
- ('\uf999', &['\u84ee']), ('\uf99a', &['\u9023']), ('\uf99b', &['\u934a']), ('\uf99c',
- &['\u5217']), ('\uf99d', &['\u52a3']), ('\uf99e', &['\u54bd']), ('\uf99f', &['\u70c8']),
- ('\uf9a0', &['\u88c2']), ('\uf9a1', &['\u8aaa']), ('\uf9a2', &['\u5ec9']), ('\uf9a3',
- &['\u5ff5']), ('\uf9a4', &['\u637b']), ('\uf9a5', &['\u6bae']), ('\uf9a6', &['\u7c3e']),
- ('\uf9a7', &['\u7375']), ('\uf9a8', &['\u4ee4']), ('\uf9a9', &['\u56f9']), ('\uf9aa',
- &['\u5be7']), ('\uf9ab', &['\u5dba']), ('\uf9ac', &['\u601c']), ('\uf9ad', &['\u73b2']),
- ('\uf9ae', &['\u7469']), ('\uf9af', &['\u7f9a']), ('\uf9b0', &['\u8046']), ('\uf9b1',
- &['\u9234']), ('\uf9b2', &['\u96f6']), ('\uf9b3', &['\u9748']), ('\uf9b4', &['\u9818']),
- ('\uf9b5', &['\u4f8b']), ('\uf9b6', &['\u79ae']), ('\uf9b7', &['\u91b4']), ('\uf9b8',
- &['\u96b8']), ('\uf9b9', &['\u60e1']), ('\uf9ba', &['\u4e86']), ('\uf9bb', &['\u50da']),
- ('\uf9bc', &['\u5bee']), ('\uf9bd', &['\u5c3f']), ('\uf9be', &['\u6599']), ('\uf9bf',
- &['\u6a02']), ('\uf9c0', &['\u71ce']), ('\uf9c1', &['\u7642']), ('\uf9c2', &['\u84fc']),
- ('\uf9c3', &['\u907c']), ('\uf9c4', &['\u9f8d']), ('\uf9c5', &['\u6688']), ('\uf9c6',
- &['\u962e']), ('\uf9c7', &['\u5289']), ('\uf9c8', &['\u677b']), ('\uf9c9', &['\u67f3']),
- ('\uf9ca', &['\u6d41']), ('\uf9cb', &['\u6e9c']), ('\uf9cc', &['\u7409']), ('\uf9cd',
- &['\u7559']), ('\uf9ce', &['\u786b']), ('\uf9cf', &['\u7d10']), ('\uf9d0', &['\u985e']),
- ('\uf9d1', &['\u516d']), ('\uf9d2', &['\u622e']), ('\uf9d3', &['\u9678']), ('\uf9d4',
- &['\u502b']), ('\uf9d5', &['\u5d19']), ('\uf9d6', &['\u6dea']), ('\uf9d7', &['\u8f2a']),
- ('\uf9d8', &['\u5f8b']), ('\uf9d9', &['\u6144']), ('\uf9da', &['\u6817']), ('\uf9db',
- &['\u7387']), ('\uf9dc', &['\u9686']), ('\uf9dd', &['\u5229']), ('\uf9de', &['\u540f']),
- ('\uf9df', &['\u5c65']), ('\uf9e0', &['\u6613']), ('\uf9e1', &['\u674e']), ('\uf9e2',
- &['\u68a8']), ('\uf9e3', &['\u6ce5']), ('\uf9e4', &['\u7406']), ('\uf9e5', &['\u75e2']),
- ('\uf9e6', &['\u7f79']), ('\uf9e7', &['\u88cf']), ('\uf9e8', &['\u88e1']), ('\uf9e9',
- &['\u91cc']), ('\uf9ea', &['\u96e2']), ('\uf9eb', &['\u533f']), ('\uf9ec', &['\u6eba']),
- ('\uf9ed', &['\u541d']), ('\uf9ee', &['\u71d0']), ('\uf9ef', &['\u7498']), ('\uf9f0',
- &['\u85fa']), ('\uf9f1', &['\u96a3']), ('\uf9f2', &['\u9c57']), ('\uf9f3', &['\u9e9f']),
- ('\uf9f4', &['\u6797']), ('\uf9f5', &['\u6dcb']), ('\uf9f6', &['\u81e8']), ('\uf9f7',
- &['\u7acb']), ('\uf9f8', &['\u7b20']), ('\uf9f9', &['\u7c92']), ('\uf9fa', &['\u72c0']),
- ('\uf9fb', &['\u7099']), ('\uf9fc', &['\u8b58']), ('\uf9fd', &['\u4ec0']), ('\uf9fe',
- &['\u8336']), ('\uf9ff', &['\u523a']), ('\ufa00', &['\u5207']), ('\ufa01', &['\u5ea6']),
- ('\ufa02', &['\u62d3']), ('\ufa03', &['\u7cd6']), ('\ufa04', &['\u5b85']), ('\ufa05',
- &['\u6d1e']), ('\ufa06', &['\u66b4']), ('\ufa07', &['\u8f3b']), ('\ufa08', &['\u884c']),
- ('\ufa09', &['\u964d']), ('\ufa0a', &['\u898b']), ('\ufa0b', &['\u5ed3']), ('\ufa0c',
- &['\u5140']), ('\ufa0d', &['\u55c0']), ('\ufa10', &['\u585a']), ('\ufa12', &['\u6674']),
- ('\ufa15', &['\u51de']), ('\ufa16', &['\u732a']), ('\ufa17', &['\u76ca']), ('\ufa18',
- &['\u793c']), ('\ufa19', &['\u795e']), ('\ufa1a', &['\u7965']), ('\ufa1b', &['\u798f']),
- ('\ufa1c', &['\u9756']), ('\ufa1d', &['\u7cbe']), ('\ufa1e', &['\u7fbd']), ('\ufa20',
- &['\u8612']), ('\ufa22', &['\u8af8']), ('\ufa25', &['\u9038']), ('\ufa26', &['\u90fd']),
- ('\ufa2a', &['\u98ef']), ('\ufa2b', &['\u98fc']), ('\ufa2c', &['\u9928']), ('\ufa2d',
- &['\u9db4']), ('\ufa2e', &['\u90de']), ('\ufa2f', &['\u96b7']), ('\ufa30', &['\u4fae']),
- ('\ufa31', &['\u50e7']), ('\ufa32', &['\u514d']), ('\ufa33', &['\u52c9']), ('\ufa34',
- &['\u52e4']), ('\ufa35', &['\u5351']), ('\ufa36', &['\u559d']), ('\ufa37', &['\u5606']),
- ('\ufa38', &['\u5668']), ('\ufa39', &['\u5840']), ('\ufa3a', &['\u58a8']), ('\ufa3b',
- &['\u5c64']), ('\ufa3c', &['\u5c6e']), ('\ufa3d', &['\u6094']), ('\ufa3e', &['\u6168']),
- ('\ufa3f', &['\u618e']), ('\ufa40', &['\u61f2']), ('\ufa41', &['\u654f']), ('\ufa42',
- &['\u65e2']), ('\ufa43', &['\u6691']), ('\ufa44', &['\u6885']), ('\ufa45', &['\u6d77']),
- ('\ufa46', &['\u6e1a']), ('\ufa47', &['\u6f22']), ('\ufa48', &['\u716e']), ('\ufa49',
- &['\u722b']), ('\ufa4a', &['\u7422']), ('\ufa4b', &['\u7891']), ('\ufa4c', &['\u793e']),
- ('\ufa4d', &['\u7949']), ('\ufa4e', &['\u7948']), ('\ufa4f', &['\u7950']), ('\ufa50',
- &['\u7956']), ('\ufa51', &['\u795d']), ('\ufa52', &['\u798d']), ('\ufa53', &['\u798e']),
- ('\ufa54', &['\u7a40']), ('\ufa55', &['\u7a81']), ('\ufa56', &['\u7bc0']), ('\ufa57',
- &['\u7df4']), ('\ufa58', &['\u7e09']), ('\ufa59', &['\u7e41']), ('\ufa5a', &['\u7f72']),
- ('\ufa5b', &['\u8005']), ('\ufa5c', &['\u81ed']), ('\ufa5d', &['\u8279']), ('\ufa5e',
- &['\u8279']), ('\ufa5f', &['\u8457']), ('\ufa60', &['\u8910']), ('\ufa61', &['\u8996']),
- ('\ufa62', &['\u8b01']), ('\ufa63', &['\u8b39']), ('\ufa64', &['\u8cd3']), ('\ufa65',
- &['\u8d08']), ('\ufa66', &['\u8fb6']), ('\ufa67', &['\u9038']), ('\ufa68', &['\u96e3']),
- ('\ufa69', &['\u97ff']), ('\ufa6a', &['\u983b']), ('\ufa6b', &['\u6075']), ('\ufa6c',
- &['\U000242ee']), ('\ufa6d', &['\u8218']), ('\ufa70', &['\u4e26']), ('\ufa71', &['\u51b5']),
- ('\ufa72', &['\u5168']), ('\ufa73', &['\u4f80']), ('\ufa74', &['\u5145']), ('\ufa75',
- &['\u5180']), ('\ufa76', &['\u52c7']), ('\ufa77', &['\u52fa']), ('\ufa78', &['\u559d']),
- ('\ufa79', &['\u5555']), ('\ufa7a', &['\u5599']), ('\ufa7b', &['\u55e2']), ('\ufa7c',
- &['\u585a']), ('\ufa7d', &['\u58b3']), ('\ufa7e', &['\u5944']), ('\ufa7f', &['\u5954']),
- ('\ufa80', &['\u5a62']), ('\ufa81', &['\u5b28']), ('\ufa82', &['\u5ed2']), ('\ufa83',
- &['\u5ed9']), ('\ufa84', &['\u5f69']), ('\ufa85', &['\u5fad']), ('\ufa86', &['\u60d8']),
- ('\ufa87', &['\u614e']), ('\ufa88', &['\u6108']), ('\ufa89', &['\u618e']), ('\ufa8a',
- &['\u6160']), ('\ufa8b', &['\u61f2']), ('\ufa8c', &['\u6234']), ('\ufa8d', &['\u63c4']),
- ('\ufa8e', &['\u641c']), ('\ufa8f', &['\u6452']), ('\ufa90', &['\u6556']), ('\ufa91',
- &['\u6674']), ('\ufa92', &['\u6717']), ('\ufa93', &['\u671b']), ('\ufa94', &['\u6756']),
- ('\ufa95', &['\u6b79']), ('\ufa96', &['\u6bba']), ('\ufa97', &['\u6d41']), ('\ufa98',
- &['\u6edb']), ('\ufa99', &['\u6ecb']), ('\ufa9a', &['\u6f22']), ('\ufa9b', &['\u701e']),
- ('\ufa9c', &['\u716e']), ('\ufa9d', &['\u77a7']), ('\ufa9e', &['\u7235']), ('\ufa9f',
- &['\u72af']), ('\ufaa0', &['\u732a']), ('\ufaa1', &['\u7471']), ('\ufaa2', &['\u7506']),
- ('\ufaa3', &['\u753b']), ('\ufaa4', &['\u761d']), ('\ufaa5', &['\u761f']), ('\ufaa6',
- &['\u76ca']), ('\ufaa7', &['\u76db']), ('\ufaa8', &['\u76f4']), ('\ufaa9', &['\u774a']),
- ('\ufaaa', &['\u7740']), ('\ufaab', &['\u78cc']), ('\ufaac', &['\u7ab1']), ('\ufaad',
- &['\u7bc0']), ('\ufaae', &['\u7c7b']), ('\ufaaf', &['\u7d5b']), ('\ufab0', &['\u7df4']),
- ('\ufab1', &['\u7f3e']), ('\ufab2', &['\u8005']), ('\ufab3', &['\u8352']), ('\ufab4',
- &['\u83ef']), ('\ufab5', &['\u8779']), ('\ufab6', &['\u8941']), ('\ufab7', &['\u8986']),
- ('\ufab8', &['\u8996']), ('\ufab9', &['\u8abf']), ('\ufaba', &['\u8af8']), ('\ufabb',
- &['\u8acb']), ('\ufabc', &['\u8b01']), ('\ufabd', &['\u8afe']), ('\ufabe', &['\u8aed']),
- ('\ufabf', &['\u8b39']), ('\ufac0', &['\u8b8a']), ('\ufac1', &['\u8d08']), ('\ufac2',
- &['\u8f38']), ('\ufac3', &['\u9072']), ('\ufac4', &['\u9199']), ('\ufac5', &['\u9276']),
- ('\ufac6', &['\u967c']), ('\ufac7', &['\u96e3']), ('\ufac8', &['\u9756']), ('\ufac9',
- &['\u97db']), ('\ufaca', &['\u97ff']), ('\ufacb', &['\u980b']), ('\ufacc', &['\u983b']),
- ('\ufacd', &['\u9b12']), ('\uface', &['\u9f9c']), ('\ufacf', &['\U0002284a']), ('\ufad0',
- &['\U00022844']), ('\ufad1', &['\U000233d5']), ('\ufad2', &['\u3b9d']), ('\ufad3',
- &['\u4018']), ('\ufad4', &['\u4039']), ('\ufad5', &['\U00025249']), ('\ufad6',
- &['\U00025cd0']), ('\ufad7', &['\U00027ed3']), ('\ufad8', &['\u9f43']), ('\ufad9',
- &['\u9f8e']), ('\ufb1d', &['\u05d9', '\u05b4']), ('\ufb1f', &['\u05f2', '\u05b7']),
- ('\ufb2a', &['\u05e9', '\u05c1']), ('\ufb2b', &['\u05e9', '\u05c2']), ('\ufb2c', &['\ufb49',
- '\u05c1']), ('\ufb2d', &['\ufb49', '\u05c2']), ('\ufb2e', &['\u05d0', '\u05b7']), ('\ufb2f',
- &['\u05d0', '\u05b8']), ('\ufb30', &['\u05d0', '\u05bc']), ('\ufb31', &['\u05d1',
- '\u05bc']), ('\ufb32', &['\u05d2', '\u05bc']), ('\ufb33', &['\u05d3', '\u05bc']), ('\ufb34',
- &['\u05d4', '\u05bc']), ('\ufb35', &['\u05d5', '\u05bc']), ('\ufb36', &['\u05d6',
- '\u05bc']), ('\ufb38', &['\u05d8', '\u05bc']), ('\ufb39', &['\u05d9', '\u05bc']), ('\ufb3a',
- &['\u05da', '\u05bc']), ('\ufb3b', &['\u05db', '\u05bc']), ('\ufb3c', &['\u05dc',
- '\u05bc']), ('\ufb3e', &['\u05de', '\u05bc']), ('\ufb40', &['\u05e0', '\u05bc']), ('\ufb41',
- &['\u05e1', '\u05bc']), ('\ufb43', &['\u05e3', '\u05bc']), ('\ufb44', &['\u05e4',
- '\u05bc']), ('\ufb46', &['\u05e6', '\u05bc']), ('\ufb47', &['\u05e7', '\u05bc']), ('\ufb48',
- &['\u05e8', '\u05bc']), ('\ufb49', &['\u05e9', '\u05bc']), ('\ufb4a', &['\u05ea',
- '\u05bc']), ('\ufb4b', &['\u05d5', '\u05b9']), ('\ufb4c', &['\u05d1', '\u05bf']), ('\ufb4d',
- &['\u05db', '\u05bf']), ('\ufb4e', &['\u05e4', '\u05bf']), ('\U0001109a', &['\U00011099',
- '\U000110ba']), ('\U0001109c', &['\U0001109b', '\U000110ba']), ('\U000110ab',
- &['\U000110a5', '\U000110ba']), ('\U0001112e', &['\U00011131', '\U00011127']),
- ('\U0001112f', &['\U00011132', '\U00011127']), ('\U0001d15e', &['\U0001d157',
- '\U0001d165']), ('\U0001d15f', &['\U0001d158', '\U0001d165']), ('\U0001d160',
- &['\U0001d15f', '\U0001d16e']), ('\U0001d161', &['\U0001d15f', '\U0001d16f']),
- ('\U0001d162', &['\U0001d15f', '\U0001d170']), ('\U0001d163', &['\U0001d15f',
- '\U0001d171']), ('\U0001d164', &['\U0001d15f', '\U0001d172']), ('\U0001d1bb',
- &['\U0001d1b9', '\U0001d165']), ('\U0001d1bc', &['\U0001d1ba', '\U0001d165']),
- ('\U0001d1bd', &['\U0001d1bb', '\U0001d16e']), ('\U0001d1be', &['\U0001d1bc',
- '\U0001d16e']), ('\U0001d1bf', &['\U0001d1bb', '\U0001d16f']), ('\U0001d1c0',
- &['\U0001d1bc', '\U0001d16f']), ('\U0002f800', &['\u4e3d']), ('\U0002f801', &['\u4e38']),
- ('\U0002f802', &['\u4e41']), ('\U0002f803', &['\U00020122']), ('\U0002f804', &['\u4f60']),
- ('\U0002f805', &['\u4fae']), ('\U0002f806', &['\u4fbb']), ('\U0002f807', &['\u5002']),
- ('\U0002f808', &['\u507a']), ('\U0002f809', &['\u5099']), ('\U0002f80a', &['\u50e7']),
- ('\U0002f80b', &['\u50cf']), ('\U0002f80c', &['\u349e']), ('\U0002f80d', &['\U0002063a']),
- ('\U0002f80e', &['\u514d']), ('\U0002f80f', &['\u5154']), ('\U0002f810', &['\u5164']),
- ('\U0002f811', &['\u5177']), ('\U0002f812', &['\U0002051c']), ('\U0002f813', &['\u34b9']),
- ('\U0002f814', &['\u5167']), ('\U0002f815', &['\u518d']), ('\U0002f816', &['\U0002054b']),
- ('\U0002f817', &['\u5197']), ('\U0002f818', &['\u51a4']), ('\U0002f819', &['\u4ecc']),
- ('\U0002f81a', &['\u51ac']), ('\U0002f81b', &['\u51b5']), ('\U0002f81c', &['\U000291df']),
- ('\U0002f81d', &['\u51f5']), ('\U0002f81e', &['\u5203']), ('\U0002f81f', &['\u34df']),
- ('\U0002f820', &['\u523b']), ('\U0002f821', &['\u5246']), ('\U0002f822', &['\u5272']),
- ('\U0002f823', &['\u5277']), ('\U0002f824', &['\u3515']), ('\U0002f825', &['\u52c7']),
- ('\U0002f826', &['\u52c9']), ('\U0002f827', &['\u52e4']), ('\U0002f828', &['\u52fa']),
- ('\U0002f829', &['\u5305']), ('\U0002f82a', &['\u5306']), ('\U0002f82b', &['\u5317']),
- ('\U0002f82c', &['\u5349']), ('\U0002f82d', &['\u5351']), ('\U0002f82e', &['\u535a']),
- ('\U0002f82f', &['\u5373']), ('\U0002f830', &['\u537d']), ('\U0002f831', &['\u537f']),
- ('\U0002f832', &['\u537f']), ('\U0002f833', &['\u537f']), ('\U0002f834', &['\U00020a2c']),
- ('\U0002f835', &['\u7070']), ('\U0002f836', &['\u53ca']), ('\U0002f837', &['\u53df']),
- ('\U0002f838', &['\U00020b63']), ('\U0002f839', &['\u53eb']), ('\U0002f83a', &['\u53f1']),
- ('\U0002f83b', &['\u5406']), ('\U0002f83c', &['\u549e']), ('\U0002f83d', &['\u5438']),
- ('\U0002f83e', &['\u5448']), ('\U0002f83f', &['\u5468']), ('\U0002f840', &['\u54a2']),
- ('\U0002f841', &['\u54f6']), ('\U0002f842', &['\u5510']), ('\U0002f843', &['\u5553']),
- ('\U0002f844', &['\u5563']), ('\U0002f845', &['\u5584']), ('\U0002f846', &['\u5584']),
- ('\U0002f847', &['\u5599']), ('\U0002f848', &['\u55ab']), ('\U0002f849', &['\u55b3']),
- ('\U0002f84a', &['\u55c2']), ('\U0002f84b', &['\u5716']), ('\U0002f84c', &['\u5606']),
- ('\U0002f84d', &['\u5717']), ('\U0002f84e', &['\u5651']), ('\U0002f84f', &['\u5674']),
- ('\U0002f850', &['\u5207']), ('\U0002f851', &['\u58ee']), ('\U0002f852', &['\u57ce']),
- ('\U0002f853', &['\u57f4']), ('\U0002f854', &['\u580d']), ('\U0002f855', &['\u578b']),
- ('\U0002f856', &['\u5832']), ('\U0002f857', &['\u5831']), ('\U0002f858', &['\u58ac']),
- ('\U0002f859', &['\U000214e4']), ('\U0002f85a', &['\u58f2']), ('\U0002f85b', &['\u58f7']),
- ('\U0002f85c', &['\u5906']), ('\U0002f85d', &['\u591a']), ('\U0002f85e', &['\u5922']),
- ('\U0002f85f', &['\u5962']), ('\U0002f860', &['\U000216a8']), ('\U0002f861',
- &['\U000216ea']), ('\U0002f862', &['\u59ec']), ('\U0002f863', &['\u5a1b']), ('\U0002f864',
- &['\u5a27']), ('\U0002f865', &['\u59d8']), ('\U0002f866', &['\u5a66']), ('\U0002f867',
- &['\u36ee']), ('\U0002f868', &['\u36fc']), ('\U0002f869', &['\u5b08']), ('\U0002f86a',
- &['\u5b3e']), ('\U0002f86b', &['\u5b3e']), ('\U0002f86c', &['\U000219c8']), ('\U0002f86d',
- &['\u5bc3']), ('\U0002f86e', &['\u5bd8']), ('\U0002f86f', &['\u5be7']), ('\U0002f870',
- &['\u5bf3']), ('\U0002f871', &['\U00021b18']), ('\U0002f872', &['\u5bff']), ('\U0002f873',
- &['\u5c06']), ('\U0002f874', &['\u5f53']), ('\U0002f875', &['\u5c22']), ('\U0002f876',
- &['\u3781']), ('\U0002f877', &['\u5c60']), ('\U0002f878', &['\u5c6e']), ('\U0002f879',
- &['\u5cc0']), ('\U0002f87a', &['\u5c8d']), ('\U0002f87b', &['\U00021de4']), ('\U0002f87c',
- &['\u5d43']), ('\U0002f87d', &['\U00021de6']), ('\U0002f87e', &['\u5d6e']), ('\U0002f87f',
- &['\u5d6b']), ('\U0002f880', &['\u5d7c']), ('\U0002f881', &['\u5de1']), ('\U0002f882',
- &['\u5de2']), ('\U0002f883', &['\u382f']), ('\U0002f884', &['\u5dfd']), ('\U0002f885',
- &['\u5e28']), ('\U0002f886', &['\u5e3d']), ('\U0002f887', &['\u5e69']), ('\U0002f888',
- &['\u3862']), ('\U0002f889', &['\U00022183']), ('\U0002f88a', &['\u387c']), ('\U0002f88b',
- &['\u5eb0']), ('\U0002f88c', &['\u5eb3']), ('\U0002f88d', &['\u5eb6']), ('\U0002f88e',
- &['\u5eca']), ('\U0002f88f', &['\U0002a392']), ('\U0002f890', &['\u5efe']), ('\U0002f891',
- &['\U00022331']), ('\U0002f892', &['\U00022331']), ('\U0002f893', &['\u8201']),
- ('\U0002f894', &['\u5f22']), ('\U0002f895', &['\u5f22']), ('\U0002f896', &['\u38c7']),
- ('\U0002f897', &['\U000232b8']), ('\U0002f898', &['\U000261da']), ('\U0002f899',
- &['\u5f62']), ('\U0002f89a', &['\u5f6b']), ('\U0002f89b', &['\u38e3']), ('\U0002f89c',
- &['\u5f9a']), ('\U0002f89d', &['\u5fcd']), ('\U0002f89e', &['\u5fd7']), ('\U0002f89f',
- &['\u5ff9']), ('\U0002f8a0', &['\u6081']), ('\U0002f8a1', &['\u393a']), ('\U0002f8a2',
- &['\u391c']), ('\U0002f8a3', &['\u6094']), ('\U0002f8a4', &['\U000226d4']), ('\U0002f8a5',
- &['\u60c7']), ('\U0002f8a6', &['\u6148']), ('\U0002f8a7', &['\u614c']), ('\U0002f8a8',
- &['\u614e']), ('\U0002f8a9', &['\u614c']), ('\U0002f8aa', &['\u617a']), ('\U0002f8ab',
- &['\u618e']), ('\U0002f8ac', &['\u61b2']), ('\U0002f8ad', &['\u61a4']), ('\U0002f8ae',
- &['\u61af']), ('\U0002f8af', &['\u61de']), ('\U0002f8b0', &['\u61f2']), ('\U0002f8b1',
- &['\u61f6']), ('\U0002f8b2', &['\u6210']), ('\U0002f8b3', &['\u621b']), ('\U0002f8b4',
- &['\u625d']), ('\U0002f8b5', &['\u62b1']), ('\U0002f8b6', &['\u62d4']), ('\U0002f8b7',
- &['\u6350']), ('\U0002f8b8', &['\U00022b0c']), ('\U0002f8b9', &['\u633d']), ('\U0002f8ba',
- &['\u62fc']), ('\U0002f8bb', &['\u6368']), ('\U0002f8bc', &['\u6383']), ('\U0002f8bd',
- &['\u63e4']), ('\U0002f8be', &['\U00022bf1']), ('\U0002f8bf', &['\u6422']), ('\U0002f8c0',
- &['\u63c5']), ('\U0002f8c1', &['\u63a9']), ('\U0002f8c2', &['\u3a2e']), ('\U0002f8c3',
- &['\u6469']), ('\U0002f8c4', &['\u647e']), ('\U0002f8c5', &['\u649d']), ('\U0002f8c6',
- &['\u6477']), ('\U0002f8c7', &['\u3a6c']), ('\U0002f8c8', &['\u654f']), ('\U0002f8c9',
- &['\u656c']), ('\U0002f8ca', &['\U0002300a']), ('\U0002f8cb', &['\u65e3']), ('\U0002f8cc',
- &['\u66f8']), ('\U0002f8cd', &['\u6649']), ('\U0002f8ce', &['\u3b19']), ('\U0002f8cf',
- &['\u6691']), ('\U0002f8d0', &['\u3b08']), ('\U0002f8d1', &['\u3ae4']), ('\U0002f8d2',
- &['\u5192']), ('\U0002f8d3', &['\u5195']), ('\U0002f8d4', &['\u6700']), ('\U0002f8d5',
- &['\u669c']), ('\U0002f8d6', &['\u80ad']), ('\U0002f8d7', &['\u43d9']), ('\U0002f8d8',
- &['\u6717']), ('\U0002f8d9', &['\u671b']), ('\U0002f8da', &['\u6721']), ('\U0002f8db',
- &['\u675e']), ('\U0002f8dc', &['\u6753']), ('\U0002f8dd', &['\U000233c3']), ('\U0002f8de',
- &['\u3b49']), ('\U0002f8df', &['\u67fa']), ('\U0002f8e0', &['\u6785']), ('\U0002f8e1',
- &['\u6852']), ('\U0002f8e2', &['\u6885']), ('\U0002f8e3', &['\U0002346d']), ('\U0002f8e4',
- &['\u688e']), ('\U0002f8e5', &['\u681f']), ('\U0002f8e6', &['\u6914']), ('\U0002f8e7',
- &['\u3b9d']), ('\U0002f8e8', &['\u6942']), ('\U0002f8e9', &['\u69a3']), ('\U0002f8ea',
- &['\u69ea']), ('\U0002f8eb', &['\u6aa8']), ('\U0002f8ec', &['\U000236a3']), ('\U0002f8ed',
- &['\u6adb']), ('\U0002f8ee', &['\u3c18']), ('\U0002f8ef', &['\u6b21']), ('\U0002f8f0',
- &['\U000238a7']), ('\U0002f8f1', &['\u6b54']), ('\U0002f8f2', &['\u3c4e']), ('\U0002f8f3',
- &['\u6b72']), ('\U0002f8f4', &['\u6b9f']), ('\U0002f8f5', &['\u6bba']), ('\U0002f8f6',
- &['\u6bbb']), ('\U0002f8f7', &['\U00023a8d']), ('\U0002f8f8', &['\U00021d0b']),
- ('\U0002f8f9', &['\U00023afa']), ('\U0002f8fa', &['\u6c4e']), ('\U0002f8fb',
- &['\U00023cbc']), ('\U0002f8fc', &['\u6cbf']), ('\U0002f8fd', &['\u6ccd']), ('\U0002f8fe',
- &['\u6c67']), ('\U0002f8ff', &['\u6d16']), ('\U0002f900', &['\u6d3e']), ('\U0002f901',
- &['\u6d77']), ('\U0002f902', &['\u6d41']), ('\U0002f903', &['\u6d69']), ('\U0002f904',
- &['\u6d78']), ('\U0002f905', &['\u6d85']), ('\U0002f906', &['\U00023d1e']), ('\U0002f907',
- &['\u6d34']), ('\U0002f908', &['\u6e2f']), ('\U0002f909', &['\u6e6e']), ('\U0002f90a',
- &['\u3d33']), ('\U0002f90b', &['\u6ecb']), ('\U0002f90c', &['\u6ec7']), ('\U0002f90d',
- &['\U00023ed1']), ('\U0002f90e', &['\u6df9']), ('\U0002f90f', &['\u6f6e']), ('\U0002f910',
- &['\U00023f5e']), ('\U0002f911', &['\U00023f8e']), ('\U0002f912', &['\u6fc6']),
- ('\U0002f913', &['\u7039']), ('\U0002f914', &['\u701e']), ('\U0002f915', &['\u701b']),
- ('\U0002f916', &['\u3d96']), ('\U0002f917', &['\u704a']), ('\U0002f918', &['\u707d']),
- ('\U0002f919', &['\u7077']), ('\U0002f91a', &['\u70ad']), ('\U0002f91b', &['\U00020525']),
- ('\U0002f91c', &['\u7145']), ('\U0002f91d', &['\U00024263']), ('\U0002f91e', &['\u719c']),
- ('\U0002f91f', &['\U000243ab']), ('\U0002f920', &['\u7228']), ('\U0002f921', &['\u7235']),
- ('\U0002f922', &['\u7250']), ('\U0002f923', &['\U00024608']), ('\U0002f924', &['\u7280']),
- ('\U0002f925', &['\u7295']), ('\U0002f926', &['\U00024735']), ('\U0002f927',
- &['\U00024814']), ('\U0002f928', &['\u737a']), ('\U0002f929', &['\u738b']), ('\U0002f92a',
- &['\u3eac']), ('\U0002f92b', &['\u73a5']), ('\U0002f92c', &['\u3eb8']), ('\U0002f92d',
- &['\u3eb8']), ('\U0002f92e', &['\u7447']), ('\U0002f92f', &['\u745c']), ('\U0002f930',
- &['\u7471']), ('\U0002f931', &['\u7485']), ('\U0002f932', &['\u74ca']), ('\U0002f933',
- &['\u3f1b']), ('\U0002f934', &['\u7524']), ('\U0002f935', &['\U00024c36']), ('\U0002f936',
- &['\u753e']), ('\U0002f937', &['\U00024c92']), ('\U0002f938', &['\u7570']), ('\U0002f939',
- &['\U0002219f']), ('\U0002f93a', &['\u7610']), ('\U0002f93b', &['\U00024fa1']),
- ('\U0002f93c', &['\U00024fb8']), ('\U0002f93d', &['\U00025044']), ('\U0002f93e',
- &['\u3ffc']), ('\U0002f93f', &['\u4008']), ('\U0002f940', &['\u76f4']), ('\U0002f941',
- &['\U000250f3']), ('\U0002f942', &['\U000250f2']), ('\U0002f943', &['\U00025119']),
- ('\U0002f944', &['\U00025133']), ('\U0002f945', &['\u771e']), ('\U0002f946', &['\u771f']),
- ('\U0002f947', &['\u771f']), ('\U0002f948', &['\u774a']), ('\U0002f949', &['\u4039']),
- ('\U0002f94a', &['\u778b']), ('\U0002f94b', &['\u4046']), ('\U0002f94c', &['\u4096']),
- ('\U0002f94d', &['\U0002541d']), ('\U0002f94e', &['\u784e']), ('\U0002f94f', &['\u788c']),
- ('\U0002f950', &['\u78cc']), ('\U0002f951', &['\u40e3']), ('\U0002f952', &['\U00025626']),
- ('\U0002f953', &['\u7956']), ('\U0002f954', &['\U0002569a']), ('\U0002f955',
- &['\U000256c5']), ('\U0002f956', &['\u798f']), ('\U0002f957', &['\u79eb']), ('\U0002f958',
- &['\u412f']), ('\U0002f959', &['\u7a40']), ('\U0002f95a', &['\u7a4a']), ('\U0002f95b',
- &['\u7a4f']), ('\U0002f95c', &['\U0002597c']), ('\U0002f95d', &['\U00025aa7']),
- ('\U0002f95e', &['\U00025aa7']), ('\U0002f95f', &['\u7aee']), ('\U0002f960', &['\u4202']),
- ('\U0002f961', &['\U00025bab']), ('\U0002f962', &['\u7bc6']), ('\U0002f963', &['\u7bc9']),
- ('\U0002f964', &['\u4227']), ('\U0002f965', &['\U00025c80']), ('\U0002f966', &['\u7cd2']),
- ('\U0002f967', &['\u42a0']), ('\U0002f968', &['\u7ce8']), ('\U0002f969', &['\u7ce3']),
- ('\U0002f96a', &['\u7d00']), ('\U0002f96b', &['\U00025f86']), ('\U0002f96c', &['\u7d63']),
- ('\U0002f96d', &['\u4301']), ('\U0002f96e', &['\u7dc7']), ('\U0002f96f', &['\u7e02']),
- ('\U0002f970', &['\u7e45']), ('\U0002f971', &['\u4334']), ('\U0002f972', &['\U00026228']),
- ('\U0002f973', &['\U00026247']), ('\U0002f974', &['\u4359']), ('\U0002f975',
- &['\U000262d9']), ('\U0002f976', &['\u7f7a']), ('\U0002f977', &['\U0002633e']),
- ('\U0002f978', &['\u7f95']), ('\U0002f979', &['\u7ffa']), ('\U0002f97a', &['\u8005']),
- ('\U0002f97b', &['\U000264da']), ('\U0002f97c', &['\U00026523']), ('\U0002f97d',
- &['\u8060']), ('\U0002f97e', &['\U000265a8']), ('\U0002f97f', &['\u8070']), ('\U0002f980',
- &['\U0002335f']), ('\U0002f981', &['\u43d5']), ('\U0002f982', &['\u80b2']), ('\U0002f983',
- &['\u8103']), ('\U0002f984', &['\u440b']), ('\U0002f985', &['\u813e']), ('\U0002f986',
- &['\u5ab5']), ('\U0002f987', &['\U000267a7']), ('\U0002f988', &['\U000267b5']),
- ('\U0002f989', &['\U00023393']), ('\U0002f98a', &['\U0002339c']), ('\U0002f98b',
- &['\u8201']), ('\U0002f98c', &['\u8204']), ('\U0002f98d', &['\u8f9e']), ('\U0002f98e',
- &['\u446b']), ('\U0002f98f', &['\u8291']), ('\U0002f990', &['\u828b']), ('\U0002f991',
- &['\u829d']), ('\U0002f992', &['\u52b3']), ('\U0002f993', &['\u82b1']), ('\U0002f994',
- &['\u82b3']), ('\U0002f995', &['\u82bd']), ('\U0002f996', &['\u82e6']), ('\U0002f997',
- &['\U00026b3c']), ('\U0002f998', &['\u82e5']), ('\U0002f999', &['\u831d']), ('\U0002f99a',
- &['\u8363']), ('\U0002f99b', &['\u83ad']), ('\U0002f99c', &['\u8323']), ('\U0002f99d',
- &['\u83bd']), ('\U0002f99e', &['\u83e7']), ('\U0002f99f', &['\u8457']), ('\U0002f9a0',
- &['\u8353']), ('\U0002f9a1', &['\u83ca']), ('\U0002f9a2', &['\u83cc']), ('\U0002f9a3',
- &['\u83dc']), ('\U0002f9a4', &['\U00026c36']), ('\U0002f9a5', &['\U00026d6b']),
- ('\U0002f9a6', &['\U00026cd5']), ('\U0002f9a7', &['\u452b']), ('\U0002f9a8', &['\u84f1']),
- ('\U0002f9a9', &['\u84f3']), ('\U0002f9aa', &['\u8516']), ('\U0002f9ab', &['\U000273ca']),
- ('\U0002f9ac', &['\u8564']), ('\U0002f9ad', &['\U00026f2c']), ('\U0002f9ae', &['\u455d']),
- ('\U0002f9af', &['\u4561']), ('\U0002f9b0', &['\U00026fb1']), ('\U0002f9b1',
- &['\U000270d2']), ('\U0002f9b2', &['\u456b']), ('\U0002f9b3', &['\u8650']), ('\U0002f9b4',
- &['\u865c']), ('\U0002f9b5', &['\u8667']), ('\U0002f9b6', &['\u8669']), ('\U0002f9b7',
- &['\u86a9']), ('\U0002f9b8', &['\u8688']), ('\U0002f9b9', &['\u870e']), ('\U0002f9ba',
- &['\u86e2']), ('\U0002f9bb', &['\u8779']), ('\U0002f9bc', &['\u8728']), ('\U0002f9bd',
- &['\u876b']), ('\U0002f9be', &['\u8786']), ('\U0002f9bf', &['\u45d7']), ('\U0002f9c0',
- &['\u87e1']), ('\U0002f9c1', &['\u8801']), ('\U0002f9c2', &['\u45f9']), ('\U0002f9c3',
- &['\u8860']), ('\U0002f9c4', &['\u8863']), ('\U0002f9c5', &['\U00027667']), ('\U0002f9c6',
- &['\u88d7']), ('\U0002f9c7', &['\u88de']), ('\U0002f9c8', &['\u4635']), ('\U0002f9c9',
- &['\u88fa']), ('\U0002f9ca', &['\u34bb']), ('\U0002f9cb', &['\U000278ae']), ('\U0002f9cc',
- &['\U00027966']), ('\U0002f9cd', &['\u46be']), ('\U0002f9ce', &['\u46c7']), ('\U0002f9cf',
- &['\u8aa0']), ('\U0002f9d0', &['\u8aed']), ('\U0002f9d1', &['\u8b8a']), ('\U0002f9d2',
- &['\u8c55']), ('\U0002f9d3', &['\U00027ca8']), ('\U0002f9d4', &['\u8cab']), ('\U0002f9d5',
- &['\u8cc1']), ('\U0002f9d6', &['\u8d1b']), ('\U0002f9d7', &['\u8d77']), ('\U0002f9d8',
- &['\U00027f2f']), ('\U0002f9d9', &['\U00020804']), ('\U0002f9da', &['\u8dcb']),
- ('\U0002f9db', &['\u8dbc']), ('\U0002f9dc', &['\u8df0']), ('\U0002f9dd', &['\U000208de']),
- ('\U0002f9de', &['\u8ed4']), ('\U0002f9df', &['\u8f38']), ('\U0002f9e0', &['\U000285d2']),
- ('\U0002f9e1', &['\U000285ed']), ('\U0002f9e2', &['\u9094']), ('\U0002f9e3', &['\u90f1']),
- ('\U0002f9e4', &['\u9111']), ('\U0002f9e5', &['\U0002872e']), ('\U0002f9e6', &['\u911b']),
- ('\U0002f9e7', &['\u9238']), ('\U0002f9e8', &['\u92d7']), ('\U0002f9e9', &['\u92d8']),
- ('\U0002f9ea', &['\u927c']), ('\U0002f9eb', &['\u93f9']), ('\U0002f9ec', &['\u9415']),
- ('\U0002f9ed', &['\U00028bfa']), ('\U0002f9ee', &['\u958b']), ('\U0002f9ef', &['\u4995']),
- ('\U0002f9f0', &['\u95b7']), ('\U0002f9f1', &['\U00028d77']), ('\U0002f9f2', &['\u49e6']),
- ('\U0002f9f3', &['\u96c3']), ('\U0002f9f4', &['\u5db2']), ('\U0002f9f5', &['\u9723']),
- ('\U0002f9f6', &['\U00029145']), ('\U0002f9f7', &['\U0002921a']), ('\U0002f9f8',
- &['\u4a6e']), ('\U0002f9f9', &['\u4a76']), ('\U0002f9fa', &['\u97e0']), ('\U0002f9fb',
- &['\U0002940a']), ('\U0002f9fc', &['\u4ab2']), ('\U0002f9fd', &['\U00029496']),
- ('\U0002f9fe', &['\u980b']), ('\U0002f9ff', &['\u980b']), ('\U0002fa00', &['\u9829']),
- ('\U0002fa01', &['\U000295b6']), ('\U0002fa02', &['\u98e2']), ('\U0002fa03', &['\u4b33']),
- ('\U0002fa04', &['\u9929']), ('\U0002fa05', &['\u99a7']), ('\U0002fa06', &['\u99c2']),
- ('\U0002fa07', &['\u99fe']), ('\U0002fa08', &['\u4bce']), ('\U0002fa09', &['\U00029b30']),
- ('\U0002fa0a', &['\u9b12']), ('\U0002fa0b', &['\u9c40']), ('\U0002fa0c', &['\u9cfd']),
- ('\U0002fa0d', &['\u4cce']), ('\U0002fa0e', &['\u4ced']), ('\U0002fa0f', &['\u9d67']),
- ('\U0002fa10', &['\U0002a0ce']), ('\U0002fa11', &['\u4cf8']), ('\U0002fa12',
- &['\U0002a105']), ('\U0002fa13', &['\U0002a20e']), ('\U0002fa14', &['\U0002a291']),
- ('\U0002fa15', &['\u9ebb']), ('\U0002fa16', &['\u4d56']), ('\U0002fa17', &['\u9ef9']),
- ('\U0002fa18', &['\u9efe']), ('\U0002fa19', &['\u9f05']), ('\U0002fa1a', &['\u9f0f']),
- ('\U0002fa1b', &['\u9f16']), ('\U0002fa1c', &['\u9f3b']), ('\U0002fa1d', &['\U0002a600'])
- ];
-
- // Compatibility decompositions
- static compatibility_table : &'static [(char, &'static [char])] = &[
- ('\xa0', &['\x20']), ('\xa8', &['\x20', '\u0308']), ('\xaa', &['\x61']), ('\xaf', &['\x20',
- '\u0304']), ('\xb2', &['\x32']), ('\xb3', &['\x33']), ('\xb4', &['\x20', '\u0301']),
- ('\xb5', &['\u03bc']), ('\xb8', &['\x20', '\u0327']), ('\xb9', &['\x31']), ('\xba',
- &['\x6f']), ('\xbc', &['\x31', '\u2044', '\x34']), ('\xbd', &['\x31', '\u2044', '\x32']),
- ('\xbe', &['\x33', '\u2044', '\x34']), ('\u0132', &['\x49', '\x4a']), ('\u0133', &['\x69',
- '\x6a']), ('\u013f', &['\x4c', '\xb7']), ('\u0140', &['\x6c', '\xb7']), ('\u0149',
- &['\u02bc', '\x6e']), ('\u017f', &['\x73']), ('\u01c4', &['\x44', '\u017d']), ('\u01c5',
- &['\x44', '\u017e']), ('\u01c6', &['\x64', '\u017e']), ('\u01c7', &['\x4c', '\x4a']),
- ('\u01c8', &['\x4c', '\x6a']), ('\u01c9', &['\x6c', '\x6a']), ('\u01ca', &['\x4e', '\x4a']),
- ('\u01cb', &['\x4e', '\x6a']), ('\u01cc', &['\x6e', '\x6a']), ('\u01f1', &['\x44', '\x5a']),
- ('\u01f2', &['\x44', '\x7a']), ('\u01f3', &['\x64', '\x7a']), ('\u02b0', &['\x68']),
- ('\u02b1', &['\u0266']), ('\u02b2', &['\x6a']), ('\u02b3', &['\x72']), ('\u02b4',
- &['\u0279']), ('\u02b5', &['\u027b']), ('\u02b6', &['\u0281']), ('\u02b7', &['\x77']),
- ('\u02b8', &['\x79']), ('\u02d8', &['\x20', '\u0306']), ('\u02d9', &['\x20', '\u0307']),
- ('\u02da', &['\x20', '\u030a']), ('\u02db', &['\x20', '\u0328']), ('\u02dc', &['\x20',
- '\u0303']), ('\u02dd', &['\x20', '\u030b']), ('\u02e0', &['\u0263']), ('\u02e1', &['\x6c']),
- ('\u02e2', &['\x73']), ('\u02e3', &['\x78']), ('\u02e4', &['\u0295']), ('\u037a', &['\x20',
- '\u0345']), ('\u0384', &['\x20', '\u0301']), ('\u03d0', &['\u03b2']), ('\u03d1',
- &['\u03b8']), ('\u03d2', &['\u03a5']), ('\u03d5', &['\u03c6']), ('\u03d6', &['\u03c0']),
- ('\u03f0', &['\u03ba']), ('\u03f1', &['\u03c1']), ('\u03f2', &['\u03c2']), ('\u03f4',
- &['\u0398']), ('\u03f5', &['\u03b5']), ('\u03f9', &['\u03a3']), ('\u0587', &['\u0565',
- '\u0582']), ('\u0675', &['\u0627', '\u0674']), ('\u0676', &['\u0648', '\u0674']), ('\u0677',
- &['\u06c7', '\u0674']), ('\u0678', &['\u064a', '\u0674']), ('\u0e33', &['\u0e4d',
- '\u0e32']), ('\u0eb3', &['\u0ecd', '\u0eb2']), ('\u0edc', &['\u0eab', '\u0e99']), ('\u0edd',
- &['\u0eab', '\u0ea1']), ('\u0f0c', &['\u0f0b']), ('\u0f77', &['\u0fb2', '\u0f81']),
- ('\u0f79', &['\u0fb3', '\u0f81']), ('\u10fc', &['\u10dc']), ('\u1d2c', &['\x41']),
- ('\u1d2d', &['\xc6']), ('\u1d2e', &['\x42']), ('\u1d30', &['\x44']), ('\u1d31', &['\x45']),
- ('\u1d32', &['\u018e']), ('\u1d33', &['\x47']), ('\u1d34', &['\x48']), ('\u1d35',
- &['\x49']), ('\u1d36', &['\x4a']), ('\u1d37', &['\x4b']), ('\u1d38', &['\x4c']), ('\u1d39',
- &['\x4d']), ('\u1d3a', &['\x4e']), ('\u1d3c', &['\x4f']), ('\u1d3d', &['\u0222']),
- ('\u1d3e', &['\x50']), ('\u1d3f', &['\x52']), ('\u1d40', &['\x54']), ('\u1d41', &['\x55']),
- ('\u1d42', &['\x57']), ('\u1d43', &['\x61']), ('\u1d44', &['\u0250']), ('\u1d45',
- &['\u0251']), ('\u1d46', &['\u1d02']), ('\u1d47', &['\x62']), ('\u1d48', &['\x64']),
- ('\u1d49', &['\x65']), ('\u1d4a', &['\u0259']), ('\u1d4b', &['\u025b']), ('\u1d4c',
- &['\u025c']), ('\u1d4d', &['\x67']), ('\u1d4f', &['\x6b']), ('\u1d50', &['\x6d']),
- ('\u1d51', &['\u014b']), ('\u1d52', &['\x6f']), ('\u1d53', &['\u0254']), ('\u1d54',
- &['\u1d16']), ('\u1d55', &['\u1d17']), ('\u1d56', &['\x70']), ('\u1d57', &['\x74']),
- ('\u1d58', &['\x75']), ('\u1d59', &['\u1d1d']), ('\u1d5a', &['\u026f']), ('\u1d5b',
- &['\x76']), ('\u1d5c', &['\u1d25']), ('\u1d5d', &['\u03b2']), ('\u1d5e', &['\u03b3']),
- ('\u1d5f', &['\u03b4']), ('\u1d60', &['\u03c6']), ('\u1d61', &['\u03c7']), ('\u1d62',
- &['\x69']), ('\u1d63', &['\x72']), ('\u1d64', &['\x75']), ('\u1d65', &['\x76']), ('\u1d66',
- &['\u03b2']), ('\u1d67', &['\u03b3']), ('\u1d68', &['\u03c1']), ('\u1d69', &['\u03c6']),
- ('\u1d6a', &['\u03c7']), ('\u1d78', &['\u043d']), ('\u1d9b', &['\u0252']), ('\u1d9c',
- &['\x63']), ('\u1d9d', &['\u0255']), ('\u1d9e', &['\xf0']), ('\u1d9f', &['\u025c']),
- ('\u1da0', &['\x66']), ('\u1da1', &['\u025f']), ('\u1da2', &['\u0261']), ('\u1da3',
- &['\u0265']), ('\u1da4', &['\u0268']), ('\u1da5', &['\u0269']), ('\u1da6', &['\u026a']),
- ('\u1da7', &['\u1d7b']), ('\u1da8', &['\u029d']), ('\u1da9', &['\u026d']), ('\u1daa',
- &['\u1d85']), ('\u1dab', &['\u029f']), ('\u1dac', &['\u0271']), ('\u1dad', &['\u0270']),
- ('\u1dae', &['\u0272']), ('\u1daf', &['\u0273']), ('\u1db0', &['\u0274']), ('\u1db1',
- &['\u0275']), ('\u1db2', &['\u0278']), ('\u1db3', &['\u0282']), ('\u1db4', &['\u0283']),
- ('\u1db5', &['\u01ab']), ('\u1db6', &['\u0289']), ('\u1db7', &['\u028a']), ('\u1db8',
- &['\u1d1c']), ('\u1db9', &['\u028b']), ('\u1dba', &['\u028c']), ('\u1dbb', &['\x7a']),
- ('\u1dbc', &['\u0290']), ('\u1dbd', &['\u0291']), ('\u1dbe', &['\u0292']), ('\u1dbf',
- &['\u03b8']), ('\u1e9a', &['\x61', '\u02be']), ('\u1fbd', &['\x20', '\u0313']), ('\u1fbf',
- &['\x20', '\u0313']), ('\u1fc0', &['\x20', '\u0342']), ('\u1ffe', &['\x20', '\u0314']),
- ('\u2002', &['\x20']), ('\u2003', &['\x20']), ('\u2004', &['\x20']), ('\u2005', &['\x20']),
- ('\u2006', &['\x20']), ('\u2007', &['\x20']), ('\u2008', &['\x20']), ('\u2009', &['\x20']),
- ('\u200a', &['\x20']), ('\u2011', &['\u2010']), ('\u2017', &['\x20', '\u0333']), ('\u2024',
- &['\x2e']), ('\u2025', &['\x2e', '\x2e']), ('\u2026', &['\x2e', '\x2e', '\x2e']), ('\u202f',
- &['\x20']), ('\u2033', &['\u2032', '\u2032']), ('\u2034', &['\u2032', '\u2032', '\u2032']),
- ('\u2036', &['\u2035', '\u2035']), ('\u2037', &['\u2035', '\u2035', '\u2035']), ('\u203c',
- &['\x21', '\x21']), ('\u203e', &['\x20', '\u0305']), ('\u2047', &['\x3f', '\x3f']),
- ('\u2048', &['\x3f', '\x21']), ('\u2049', &['\x21', '\x3f']), ('\u2057', &['\u2032',
- '\u2032', '\u2032', '\u2032']), ('\u205f', &['\x20']), ('\u2070', &['\x30']), ('\u2071',
- &['\x69']), ('\u2074', &['\x34']), ('\u2075', &['\x35']), ('\u2076', &['\x36']), ('\u2077',
- &['\x37']), ('\u2078', &['\x38']), ('\u2079', &['\x39']), ('\u207a', &['\x2b']), ('\u207b',
- &['\u2212']), ('\u207c', &['\x3d']), ('\u207d', &['\x28']), ('\u207e', &['\x29']),
- ('\u207f', &['\x6e']), ('\u2080', &['\x30']), ('\u2081', &['\x31']), ('\u2082', &['\x32']),
- ('\u2083', &['\x33']), ('\u2084', &['\x34']), ('\u2085', &['\x35']), ('\u2086', &['\x36']),
- ('\u2087', &['\x37']), ('\u2088', &['\x38']), ('\u2089', &['\x39']), ('\u208a', &['\x2b']),
- ('\u208b', &['\u2212']), ('\u208c', &['\x3d']), ('\u208d', &['\x28']), ('\u208e',
- &['\x29']), ('\u2090', &['\x61']), ('\u2091', &['\x65']), ('\u2092', &['\x6f']), ('\u2093',
- &['\x78']), ('\u2094', &['\u0259']), ('\u2095', &['\x68']), ('\u2096', &['\x6b']),
- ('\u2097', &['\x6c']), ('\u2098', &['\x6d']), ('\u2099', &['\x6e']), ('\u209a', &['\x70']),
- ('\u209b', &['\x73']), ('\u209c', &['\x74']), ('\u20a8', &['\x52', '\x73']), ('\u2100',
- &['\x61', '\x2f', '\x63']), ('\u2101', &['\x61', '\x2f', '\x73']), ('\u2102', &['\x43']),
- ('\u2103', &['\xb0', '\x43']), ('\u2105', &['\x63', '\x2f', '\x6f']), ('\u2106', &['\x63',
- '\x2f', '\x75']), ('\u2107', &['\u0190']), ('\u2109', &['\xb0', '\x46']), ('\u210a',
- &['\x67']), ('\u210b', &['\x48']), ('\u210c', &['\x48']), ('\u210d', &['\x48']), ('\u210e',
- &['\x68']), ('\u210f', &['\u0127']), ('\u2110', &['\x49']), ('\u2111', &['\x49']),
- ('\u2112', &['\x4c']), ('\u2113', &['\x6c']), ('\u2115', &['\x4e']), ('\u2116', &['\x4e',
- '\x6f']), ('\u2119', &['\x50']), ('\u211a', &['\x51']), ('\u211b', &['\x52']), ('\u211c',
- &['\x52']), ('\u211d', &['\x52']), ('\u2120', &['\x53', '\x4d']), ('\u2121', &['\x54',
- '\x45', '\x4c']), ('\u2122', &['\x54', '\x4d']), ('\u2124', &['\x5a']), ('\u2128',
- &['\x5a']), ('\u212c', &['\x42']), ('\u212d', &['\x43']), ('\u212f', &['\x65']), ('\u2130',
- &['\x45']), ('\u2131', &['\x46']), ('\u2133', &['\x4d']), ('\u2134', &['\x6f']), ('\u2135',
- &['\u05d0']), ('\u2136', &['\u05d1']), ('\u2137', &['\u05d2']), ('\u2138', &['\u05d3']),
- ('\u2139', &['\x69']), ('\u213b', &['\x46', '\x41', '\x58']), ('\u213c', &['\u03c0']),
- ('\u213d', &['\u03b3']), ('\u213e', &['\u0393']), ('\u213f', &['\u03a0']), ('\u2140',
- &['\u2211']), ('\u2145', &['\x44']), ('\u2146', &['\x64']), ('\u2147', &['\x65']),
- ('\u2148', &['\x69']), ('\u2149', &['\x6a']), ('\u2150', &['\x31', '\u2044', '\x37']),
- ('\u2151', &['\x31', '\u2044', '\x39']), ('\u2152', &['\x31', '\u2044', '\x31', '\x30']),
- ('\u2153', &['\x31', '\u2044', '\x33']), ('\u2154', &['\x32', '\u2044', '\x33']), ('\u2155',
- &['\x31', '\u2044', '\x35']), ('\u2156', &['\x32', '\u2044', '\x35']), ('\u2157', &['\x33',
- '\u2044', '\x35']), ('\u2158', &['\x34', '\u2044', '\x35']), ('\u2159', &['\x31', '\u2044',
- '\x36']), ('\u215a', &['\x35', '\u2044', '\x36']), ('\u215b', &['\x31', '\u2044', '\x38']),
- ('\u215c', &['\x33', '\u2044', '\x38']), ('\u215d', &['\x35', '\u2044', '\x38']), ('\u215e',
- &['\x37', '\u2044', '\x38']), ('\u215f', &['\x31', '\u2044']), ('\u2160', &['\x49']),
- ('\u2161', &['\x49', '\x49']), ('\u2162', &['\x49', '\x49', '\x49']), ('\u2163', &['\x49',
- '\x56']), ('\u2164', &['\x56']), ('\u2165', &['\x56', '\x49']), ('\u2166', &['\x56', '\x49',
- '\x49']), ('\u2167', &['\x56', '\x49', '\x49', '\x49']), ('\u2168', &['\x49', '\x58']),
- ('\u2169', &['\x58']), ('\u216a', &['\x58', '\x49']), ('\u216b', &['\x58', '\x49', '\x49']),
- ('\u216c', &['\x4c']), ('\u216d', &['\x43']), ('\u216e', &['\x44']), ('\u216f', &['\x4d']),
- ('\u2170', &['\x69']), ('\u2171', &['\x69', '\x69']), ('\u2172', &['\x69', '\x69', '\x69']),
- ('\u2173', &['\x69', '\x76']), ('\u2174', &['\x76']), ('\u2175', &['\x76', '\x69']),
- ('\u2176', &['\x76', '\x69', '\x69']), ('\u2177', &['\x76', '\x69', '\x69', '\x69']),
- ('\u2178', &['\x69', '\x78']), ('\u2179', &['\x78']), ('\u217a', &['\x78', '\x69']),
- ('\u217b', &['\x78', '\x69', '\x69']), ('\u217c', &['\x6c']), ('\u217d', &['\x63']),
- ('\u217e', &['\x64']), ('\u217f', &['\x6d']), ('\u2189', &['\x30', '\u2044', '\x33']),
- ('\u222c', &['\u222b', '\u222b']), ('\u222d', &['\u222b', '\u222b', '\u222b']), ('\u222f',
- &['\u222e', '\u222e']), ('\u2230', &['\u222e', '\u222e', '\u222e']), ('\u2460', &['\x31']),
- ('\u2461', &['\x32']), ('\u2462', &['\x33']), ('\u2463', &['\x34']), ('\u2464', &['\x35']),
- ('\u2465', &['\x36']), ('\u2466', &['\x37']), ('\u2467', &['\x38']), ('\u2468', &['\x39']),
- ('\u2469', &['\x31', '\x30']), ('\u246a', &['\x31', '\x31']), ('\u246b', &['\x31', '\x32']),
- ('\u246c', &['\x31', '\x33']), ('\u246d', &['\x31', '\x34']), ('\u246e', &['\x31', '\x35']),
- ('\u246f', &['\x31', '\x36']), ('\u2470', &['\x31', '\x37']), ('\u2471', &['\x31', '\x38']),
- ('\u2472', &['\x31', '\x39']), ('\u2473', &['\x32', '\x30']), ('\u2474', &['\x28', '\x31',
- '\x29']), ('\u2475', &['\x28', '\x32', '\x29']), ('\u2476', &['\x28', '\x33', '\x29']),
- ('\u2477', &['\x28', '\x34', '\x29']), ('\u2478', &['\x28', '\x35', '\x29']), ('\u2479',
- &['\x28', '\x36', '\x29']), ('\u247a', &['\x28', '\x37', '\x29']), ('\u247b', &['\x28',
- '\x38', '\x29']), ('\u247c', &['\x28', '\x39', '\x29']), ('\u247d', &['\x28', '\x31',
- '\x30', '\x29']), ('\u247e', &['\x28', '\x31', '\x31', '\x29']), ('\u247f', &['\x28',
- '\x31', '\x32', '\x29']), ('\u2480', &['\x28', '\x31', '\x33', '\x29']), ('\u2481',
- &['\x28', '\x31', '\x34', '\x29']), ('\u2482', &['\x28', '\x31', '\x35', '\x29']),
- ('\u2483', &['\x28', '\x31', '\x36', '\x29']), ('\u2484', &['\x28', '\x31', '\x37',
- '\x29']), ('\u2485', &['\x28', '\x31', '\x38', '\x29']), ('\u2486', &['\x28', '\x31',
- '\x39', '\x29']), ('\u2487', &['\x28', '\x32', '\x30', '\x29']), ('\u2488', &['\x31',
- '\x2e']), ('\u2489', &['\x32', '\x2e']), ('\u248a', &['\x33', '\x2e']), ('\u248b', &['\x34',
- '\x2e']), ('\u248c', &['\x35', '\x2e']), ('\u248d', &['\x36', '\x2e']), ('\u248e', &['\x37',
- '\x2e']), ('\u248f', &['\x38', '\x2e']), ('\u2490', &['\x39', '\x2e']), ('\u2491', &['\x31',
- '\x30', '\x2e']), ('\u2492', &['\x31', '\x31', '\x2e']), ('\u2493', &['\x31', '\x32',
- '\x2e']), ('\u2494', &['\x31', '\x33', '\x2e']), ('\u2495', &['\x31', '\x34', '\x2e']),
- ('\u2496', &['\x31', '\x35', '\x2e']), ('\u2497', &['\x31', '\x36', '\x2e']), ('\u2498',
- &['\x31', '\x37', '\x2e']), ('\u2499', &['\x31', '\x38', '\x2e']), ('\u249a', &['\x31',
- '\x39', '\x2e']), ('\u249b', &['\x32', '\x30', '\x2e']), ('\u249c', &['\x28', '\x61',
- '\x29']), ('\u249d', &['\x28', '\x62', '\x29']), ('\u249e', &['\x28', '\x63', '\x29']),
- ('\u249f', &['\x28', '\x64', '\x29']), ('\u24a0', &['\x28', '\x65', '\x29']), ('\u24a1',
- &['\x28', '\x66', '\x29']), ('\u24a2', &['\x28', '\x67', '\x29']), ('\u24a3', &['\x28',
- '\x68', '\x29']), ('\u24a4', &['\x28', '\x69', '\x29']), ('\u24a5', &['\x28', '\x6a',
- '\x29']), ('\u24a6', &['\x28', '\x6b', '\x29']), ('\u24a7', &['\x28', '\x6c', '\x29']),
- ('\u24a8', &['\x28', '\x6d', '\x29']), ('\u24a9', &['\x28', '\x6e', '\x29']), ('\u24aa',
- &['\x28', '\x6f', '\x29']), ('\u24ab', &['\x28', '\x70', '\x29']), ('\u24ac', &['\x28',
- '\x71', '\x29']), ('\u24ad', &['\x28', '\x72', '\x29']), ('\u24ae', &['\x28', '\x73',
- '\x29']), ('\u24af', &['\x28', '\x74', '\x29']), ('\u24b0', &['\x28', '\x75', '\x29']),
- ('\u24b1', &['\x28', '\x76', '\x29']), ('\u24b2', &['\x28', '\x77', '\x29']), ('\u24b3',
- &['\x28', '\x78', '\x29']), ('\u24b4', &['\x28', '\x79', '\x29']), ('\u24b5', &['\x28',
- '\x7a', '\x29']), ('\u24b6', &['\x41']), ('\u24b7', &['\x42']), ('\u24b8', &['\x43']),
- ('\u24b9', &['\x44']), ('\u24ba', &['\x45']), ('\u24bb', &['\x46']), ('\u24bc', &['\x47']),
- ('\u24bd', &['\x48']), ('\u24be', &['\x49']), ('\u24bf', &['\x4a']), ('\u24c0', &['\x4b']),
- ('\u24c1', &['\x4c']), ('\u24c2', &['\x4d']), ('\u24c3', &['\x4e']), ('\u24c4', &['\x4f']),
- ('\u24c5', &['\x50']), ('\u24c6', &['\x51']), ('\u24c7', &['\x52']), ('\u24c8', &['\x53']),
- ('\u24c9', &['\x54']), ('\u24ca', &['\x55']), ('\u24cb', &['\x56']), ('\u24cc', &['\x57']),
- ('\u24cd', &['\x58']), ('\u24ce', &['\x59']), ('\u24cf', &['\x5a']), ('\u24d0', &['\x61']),
- ('\u24d1', &['\x62']), ('\u24d2', &['\x63']), ('\u24d3', &['\x64']), ('\u24d4', &['\x65']),
- ('\u24d5', &['\x66']), ('\u24d6', &['\x67']), ('\u24d7', &['\x68']), ('\u24d8', &['\x69']),
- ('\u24d9', &['\x6a']), ('\u24da', &['\x6b']), ('\u24db', &['\x6c']), ('\u24dc', &['\x6d']),
- ('\u24dd', &['\x6e']), ('\u24de', &['\x6f']), ('\u24df', &['\x70']), ('\u24e0', &['\x71']),
- ('\u24e1', &['\x72']), ('\u24e2', &['\x73']), ('\u24e3', &['\x74']), ('\u24e4', &['\x75']),
- ('\u24e5', &['\x76']), ('\u24e6', &['\x77']), ('\u24e7', &['\x78']), ('\u24e8', &['\x79']),
- ('\u24e9', &['\x7a']), ('\u24ea', &['\x30']), ('\u2a0c', &['\u222b', '\u222b', '\u222b',
- '\u222b']), ('\u2a74', &['\x3a', '\x3a', '\x3d']), ('\u2a75', &['\x3d', '\x3d']), ('\u2a76',
- &['\x3d', '\x3d', '\x3d']), ('\u2c7c', &['\x6a']), ('\u2c7d', &['\x56']), ('\u2d6f',
- &['\u2d61']), ('\u2e9f', &['\u6bcd']), ('\u2ef3', &['\u9f9f']), ('\u2f00', &['\u4e00']),
- ('\u2f01', &['\u4e28']), ('\u2f02', &['\u4e36']), ('\u2f03', &['\u4e3f']), ('\u2f04',
- &['\u4e59']), ('\u2f05', &['\u4e85']), ('\u2f06', &['\u4e8c']), ('\u2f07', &['\u4ea0']),
- ('\u2f08', &['\u4eba']), ('\u2f09', &['\u513f']), ('\u2f0a', &['\u5165']), ('\u2f0b',
- &['\u516b']), ('\u2f0c', &['\u5182']), ('\u2f0d', &['\u5196']), ('\u2f0e', &['\u51ab']),
- ('\u2f0f', &['\u51e0']), ('\u2f10', &['\u51f5']), ('\u2f11', &['\u5200']), ('\u2f12',
- &['\u529b']), ('\u2f13', &['\u52f9']), ('\u2f14', &['\u5315']), ('\u2f15', &['\u531a']),
- ('\u2f16', &['\u5338']), ('\u2f17', &['\u5341']), ('\u2f18', &['\u535c']), ('\u2f19',
- &['\u5369']), ('\u2f1a', &['\u5382']), ('\u2f1b', &['\u53b6']), ('\u2f1c', &['\u53c8']),
- ('\u2f1d', &['\u53e3']), ('\u2f1e', &['\u56d7']), ('\u2f1f', &['\u571f']), ('\u2f20',
- &['\u58eb']), ('\u2f21', &['\u5902']), ('\u2f22', &['\u590a']), ('\u2f23', &['\u5915']),
- ('\u2f24', &['\u5927']), ('\u2f25', &['\u5973']), ('\u2f26', &['\u5b50']), ('\u2f27',
- &['\u5b80']), ('\u2f28', &['\u5bf8']), ('\u2f29', &['\u5c0f']), ('\u2f2a', &['\u5c22']),
- ('\u2f2b', &['\u5c38']), ('\u2f2c', &['\u5c6e']), ('\u2f2d', &['\u5c71']), ('\u2f2e',
- &['\u5ddb']), ('\u2f2f', &['\u5de5']), ('\u2f30', &['\u5df1']), ('\u2f31', &['\u5dfe']),
- ('\u2f32', &['\u5e72']), ('\u2f33', &['\u5e7a']), ('\u2f34', &['\u5e7f']), ('\u2f35',
- &['\u5ef4']), ('\u2f36', &['\u5efe']), ('\u2f37', &['\u5f0b']), ('\u2f38', &['\u5f13']),
- ('\u2f39', &['\u5f50']), ('\u2f3a', &['\u5f61']), ('\u2f3b', &['\u5f73']), ('\u2f3c',
- &['\u5fc3']), ('\u2f3d', &['\u6208']), ('\u2f3e', &['\u6236']), ('\u2f3f', &['\u624b']),
- ('\u2f40', &['\u652f']), ('\u2f41', &['\u6534']), ('\u2f42', &['\u6587']), ('\u2f43',
- &['\u6597']), ('\u2f44', &['\u65a4']), ('\u2f45', &['\u65b9']), ('\u2f46', &['\u65e0']),
- ('\u2f47', &['\u65e5']), ('\u2f48', &['\u66f0']), ('\u2f49', &['\u6708']), ('\u2f4a',
- &['\u6728']), ('\u2f4b', &['\u6b20']), ('\u2f4c', &['\u6b62']), ('\u2f4d', &['\u6b79']),
- ('\u2f4e', &['\u6bb3']), ('\u2f4f', &['\u6bcb']), ('\u2f50', &['\u6bd4']), ('\u2f51',
- &['\u6bdb']), ('\u2f52', &['\u6c0f']), ('\u2f53', &['\u6c14']), ('\u2f54', &['\u6c34']),
- ('\u2f55', &['\u706b']), ('\u2f56', &['\u722a']), ('\u2f57', &['\u7236']), ('\u2f58',
- &['\u723b']), ('\u2f59', &['\u723f']), ('\u2f5a', &['\u7247']), ('\u2f5b', &['\u7259']),
- ('\u2f5c', &['\u725b']), ('\u2f5d', &['\u72ac']), ('\u2f5e', &['\u7384']), ('\u2f5f',
- &['\u7389']), ('\u2f60', &['\u74dc']), ('\u2f61', &['\u74e6']), ('\u2f62', &['\u7518']),
- ('\u2f63', &['\u751f']), ('\u2f64', &['\u7528']), ('\u2f65', &['\u7530']), ('\u2f66',
- &['\u758b']), ('\u2f67', &['\u7592']), ('\u2f68', &['\u7676']), ('\u2f69', &['\u767d']),
- ('\u2f6a', &['\u76ae']), ('\u2f6b', &['\u76bf']), ('\u2f6c', &['\u76ee']), ('\u2f6d',
- &['\u77db']), ('\u2f6e', &['\u77e2']), ('\u2f6f', &['\u77f3']), ('\u2f70', &['\u793a']),
- ('\u2f71', &['\u79b8']), ('\u2f72', &['\u79be']), ('\u2f73', &['\u7a74']), ('\u2f74',
- &['\u7acb']), ('\u2f75', &['\u7af9']), ('\u2f76', &['\u7c73']), ('\u2f77', &['\u7cf8']),
- ('\u2f78', &['\u7f36']), ('\u2f79', &['\u7f51']), ('\u2f7a', &['\u7f8a']), ('\u2f7b',
- &['\u7fbd']), ('\u2f7c', &['\u8001']), ('\u2f7d', &['\u800c']), ('\u2f7e', &['\u8012']),
- ('\u2f7f', &['\u8033']), ('\u2f80', &['\u807f']), ('\u2f81', &['\u8089']), ('\u2f82',
- &['\u81e3']), ('\u2f83', &['\u81ea']), ('\u2f84', &['\u81f3']), ('\u2f85', &['\u81fc']),
- ('\u2f86', &['\u820c']), ('\u2f87', &['\u821b']), ('\u2f88', &['\u821f']), ('\u2f89',
- &['\u826e']), ('\u2f8a', &['\u8272']), ('\u2f8b', &['\u8278']), ('\u2f8c', &['\u864d']),
- ('\u2f8d', &['\u866b']), ('\u2f8e', &['\u8840']), ('\u2f8f', &['\u884c']), ('\u2f90',
- &['\u8863']), ('\u2f91', &['\u897e']), ('\u2f92', &['\u898b']), ('\u2f93', &['\u89d2']),
- ('\u2f94', &['\u8a00']), ('\u2f95', &['\u8c37']), ('\u2f96', &['\u8c46']), ('\u2f97',
- &['\u8c55']), ('\u2f98', &['\u8c78']), ('\u2f99', &['\u8c9d']), ('\u2f9a', &['\u8d64']),
- ('\u2f9b', &['\u8d70']), ('\u2f9c', &['\u8db3']), ('\u2f9d', &['\u8eab']), ('\u2f9e',
- &['\u8eca']), ('\u2f9f', &['\u8f9b']), ('\u2fa0', &['\u8fb0']), ('\u2fa1', &['\u8fb5']),
- ('\u2fa2', &['\u9091']), ('\u2fa3', &['\u9149']), ('\u2fa4', &['\u91c6']), ('\u2fa5',
- &['\u91cc']), ('\u2fa6', &['\u91d1']), ('\u2fa7', &['\u9577']), ('\u2fa8', &['\u9580']),
- ('\u2fa9', &['\u961c']), ('\u2faa', &['\u96b6']), ('\u2fab', &['\u96b9']), ('\u2fac',
- &['\u96e8']), ('\u2fad', &['\u9751']), ('\u2fae', &['\u975e']), ('\u2faf', &['\u9762']),
- ('\u2fb0', &['\u9769']), ('\u2fb1', &['\u97cb']), ('\u2fb2', &['\u97ed']), ('\u2fb3',
- &['\u97f3']), ('\u2fb4', &['\u9801']), ('\u2fb5', &['\u98a8']), ('\u2fb6', &['\u98db']),
- ('\u2fb7', &['\u98df']), ('\u2fb8', &['\u9996']), ('\u2fb9', &['\u9999']), ('\u2fba',
- &['\u99ac']), ('\u2fbb', &['\u9aa8']), ('\u2fbc', &['\u9ad8']), ('\u2fbd', &['\u9adf']),
- ('\u2fbe', &['\u9b25']), ('\u2fbf', &['\u9b2f']), ('\u2fc0', &['\u9b32']), ('\u2fc1',
- &['\u9b3c']), ('\u2fc2', &['\u9b5a']), ('\u2fc3', &['\u9ce5']), ('\u2fc4', &['\u9e75']),
- ('\u2fc5', &['\u9e7f']), ('\u2fc6', &['\u9ea5']), ('\u2fc7', &['\u9ebb']), ('\u2fc8',
- &['\u9ec3']), ('\u2fc9', &['\u9ecd']), ('\u2fca', &['\u9ed1']), ('\u2fcb', &['\u9ef9']),
- ('\u2fcc', &['\u9efd']), ('\u2fcd', &['\u9f0e']), ('\u2fce', &['\u9f13']), ('\u2fcf',
- &['\u9f20']), ('\u2fd0', &['\u9f3b']), ('\u2fd1', &['\u9f4a']), ('\u2fd2', &['\u9f52']),
- ('\u2fd3', &['\u9f8d']), ('\u2fd4', &['\u9f9c']), ('\u2fd5', &['\u9fa0']), ('\u3000',
- &['\x20']), ('\u3036', &['\u3012']), ('\u3038', &['\u5341']), ('\u3039', &['\u5344']),
- ('\u303a', &['\u5345']), ('\u309b', &['\x20', '\u3099']), ('\u309c', &['\x20', '\u309a']),
- ('\u309f', &['\u3088', '\u308a']), ('\u30ff', &['\u30b3', '\u30c8']), ('\u3131',
- &['\u1100']), ('\u3132', &['\u1101']), ('\u3133', &['\u11aa']), ('\u3134', &['\u1102']),
- ('\u3135', &['\u11ac']), ('\u3136', &['\u11ad']), ('\u3137', &['\u1103']), ('\u3138',
- &['\u1104']), ('\u3139', &['\u1105']), ('\u313a', &['\u11b0']), ('\u313b', &['\u11b1']),
- ('\u313c', &['\u11b2']), ('\u313d', &['\u11b3']), ('\u313e', &['\u11b4']), ('\u313f',
- &['\u11b5']), ('\u3140', &['\u111a']), ('\u3141', &['\u1106']), ('\u3142', &['\u1107']),
- ('\u3143', &['\u1108']), ('\u3144', &['\u1121']), ('\u3145', &['\u1109']), ('\u3146',
- &['\u110a']), ('\u3147', &['\u110b']), ('\u3148', &['\u110c']), ('\u3149', &['\u110d']),
- ('\u314a', &['\u110e']), ('\u314b', &['\u110f']), ('\u314c', &['\u1110']), ('\u314d',
- &['\u1111']), ('\u314e', &['\u1112']), ('\u314f', &['\u1161']), ('\u3150', &['\u1162']),
- ('\u3151', &['\u1163']), ('\u3152', &['\u1164']), ('\u3153', &['\u1165']), ('\u3154',
- &['\u1166']), ('\u3155', &['\u1167']), ('\u3156', &['\u1168']), ('\u3157', &['\u1169']),
- ('\u3158', &['\u116a']), ('\u3159', &['\u116b']), ('\u315a', &['\u116c']), ('\u315b',
- &['\u116d']), ('\u315c', &['\u116e']), ('\u315d', &['\u116f']), ('\u315e', &['\u1170']),
- ('\u315f', &['\u1171']), ('\u3160', &['\u1172']), ('\u3161', &['\u1173']), ('\u3162',
- &['\u1174']), ('\u3163', &['\u1175']), ('\u3164', &['\u1160']), ('\u3165', &['\u1114']),
- ('\u3166', &['\u1115']), ('\u3167', &['\u11c7']), ('\u3168', &['\u11c8']), ('\u3169',
- &['\u11cc']), ('\u316a', &['\u11ce']), ('\u316b', &['\u11d3']), ('\u316c', &['\u11d7']),
- ('\u316d', &['\u11d9']), ('\u316e', &['\u111c']), ('\u316f', &['\u11dd']), ('\u3170',
- &['\u11df']), ('\u3171', &['\u111d']), ('\u3172', &['\u111e']), ('\u3173', &['\u1120']),
- ('\u3174', &['\u1122']), ('\u3175', &['\u1123']), ('\u3176', &['\u1127']), ('\u3177',
- &['\u1129']), ('\u3178', &['\u112b']), ('\u3179', &['\u112c']), ('\u317a', &['\u112d']),
- ('\u317b', &['\u112e']), ('\u317c', &['\u112f']), ('\u317d', &['\u1132']), ('\u317e',
- &['\u1136']), ('\u317f', &['\u1140']), ('\u3180', &['\u1147']), ('\u3181', &['\u114c']),
- ('\u3182', &['\u11f1']), ('\u3183', &['\u11f2']), ('\u3184', &['\u1157']), ('\u3185',
- &['\u1158']), ('\u3186', &['\u1159']), ('\u3187', &['\u1184']), ('\u3188', &['\u1185']),
- ('\u3189', &['\u1188']), ('\u318a', &['\u1191']), ('\u318b', &['\u1192']), ('\u318c',
- &['\u1194']), ('\u318d', &['\u119e']), ('\u318e', &['\u11a1']), ('\u3192', &['\u4e00']),
- ('\u3193', &['\u4e8c']), ('\u3194', &['\u4e09']), ('\u3195', &['\u56db']), ('\u3196',
- &['\u4e0a']), ('\u3197', &['\u4e2d']), ('\u3198', &['\u4e0b']), ('\u3199', &['\u7532']),
- ('\u319a', &['\u4e59']), ('\u319b', &['\u4e19']), ('\u319c', &['\u4e01']), ('\u319d',
- &['\u5929']), ('\u319e', &['\u5730']), ('\u319f', &['\u4eba']), ('\u3200', &['\x28',
- '\u1100', '\x29']), ('\u3201', &['\x28', '\u1102', '\x29']), ('\u3202', &['\x28', '\u1103',
- '\x29']), ('\u3203', &['\x28', '\u1105', '\x29']), ('\u3204', &['\x28', '\u1106', '\x29']),
- ('\u3205', &['\x28', '\u1107', '\x29']), ('\u3206', &['\x28', '\u1109', '\x29']), ('\u3207',
- &['\x28', '\u110b', '\x29']), ('\u3208', &['\x28', '\u110c', '\x29']), ('\u3209', &['\x28',
- '\u110e', '\x29']), ('\u320a', &['\x28', '\u110f', '\x29']), ('\u320b', &['\x28', '\u1110',
- '\x29']), ('\u320c', &['\x28', '\u1111', '\x29']), ('\u320d', &['\x28', '\u1112', '\x29']),
- ('\u320e', &['\x28', '\u1100', '\u1161', '\x29']), ('\u320f', &['\x28', '\u1102', '\u1161',
- '\x29']), ('\u3210', &['\x28', '\u1103', '\u1161', '\x29']), ('\u3211', &['\x28', '\u1105',
- '\u1161', '\x29']), ('\u3212', &['\x28', '\u1106', '\u1161', '\x29']), ('\u3213', &['\x28',
- '\u1107', '\u1161', '\x29']), ('\u3214', &['\x28', '\u1109', '\u1161', '\x29']), ('\u3215',
- &['\x28', '\u110b', '\u1161', '\x29']), ('\u3216', &['\x28', '\u110c', '\u1161', '\x29']),
- ('\u3217', &['\x28', '\u110e', '\u1161', '\x29']), ('\u3218', &['\x28', '\u110f', '\u1161',
- '\x29']), ('\u3219', &['\x28', '\u1110', '\u1161', '\x29']), ('\u321a', &['\x28', '\u1111',
- '\u1161', '\x29']), ('\u321b', &['\x28', '\u1112', '\u1161', '\x29']), ('\u321c', &['\x28',
- '\u110c', '\u116e', '\x29']), ('\u321d', &['\x28', '\u110b', '\u1169', '\u110c', '\u1165',
- '\u11ab', '\x29']), ('\u321e', &['\x28', '\u110b', '\u1169', '\u1112', '\u116e', '\x29']),
- ('\u3220', &['\x28', '\u4e00', '\x29']), ('\u3221', &['\x28', '\u4e8c', '\x29']), ('\u3222',
- &['\x28', '\u4e09', '\x29']), ('\u3223', &['\x28', '\u56db', '\x29']), ('\u3224', &['\x28',
- '\u4e94', '\x29']), ('\u3225', &['\x28', '\u516d', '\x29']), ('\u3226', &['\x28', '\u4e03',
- '\x29']), ('\u3227', &['\x28', '\u516b', '\x29']), ('\u3228', &['\x28', '\u4e5d', '\x29']),
- ('\u3229', &['\x28', '\u5341', '\x29']), ('\u322a', &['\x28', '\u6708', '\x29']), ('\u322b',
- &['\x28', '\u706b', '\x29']), ('\u322c', &['\x28', '\u6c34', '\x29']), ('\u322d', &['\x28',
- '\u6728', '\x29']), ('\u322e', &['\x28', '\u91d1', '\x29']), ('\u322f', &['\x28', '\u571f',
- '\x29']), ('\u3230', &['\x28', '\u65e5', '\x29']), ('\u3231', &['\x28', '\u682a', '\x29']),
- ('\u3232', &['\x28', '\u6709', '\x29']), ('\u3233', &['\x28', '\u793e', '\x29']), ('\u3234',
- &['\x28', '\u540d', '\x29']), ('\u3235', &['\x28', '\u7279', '\x29']), ('\u3236', &['\x28',
- '\u8ca1', '\x29']), ('\u3237', &['\x28', '\u795d', '\x29']), ('\u3238', &['\x28', '\u52b4',
- '\x29']), ('\u3239', &['\x28', '\u4ee3', '\x29']), ('\u323a', &['\x28', '\u547c', '\x29']),
- ('\u323b', &['\x28', '\u5b66', '\x29']), ('\u323c', &['\x28', '\u76e3', '\x29']), ('\u323d',
- &['\x28', '\u4f01', '\x29']), ('\u323e', &['\x28', '\u8cc7', '\x29']), ('\u323f', &['\x28',
- '\u5354', '\x29']), ('\u3240', &['\x28', '\u796d', '\x29']), ('\u3241', &['\x28', '\u4f11',
- '\x29']), ('\u3242', &['\x28', '\u81ea', '\x29']), ('\u3243', &['\x28', '\u81f3', '\x29']),
- ('\u3244', &['\u554f']), ('\u3245', &['\u5e7c']), ('\u3246', &['\u6587']), ('\u3247',
- &['\u7b8f']), ('\u3250', &['\x50', '\x54', '\x45']), ('\u3251', &['\x32', '\x31']),
- ('\u3252', &['\x32', '\x32']), ('\u3253', &['\x32', '\x33']), ('\u3254', &['\x32', '\x34']),
- ('\u3255', &['\x32', '\x35']), ('\u3256', &['\x32', '\x36']), ('\u3257', &['\x32', '\x37']),
- ('\u3258', &['\x32', '\x38']), ('\u3259', &['\x32', '\x39']), ('\u325a', &['\x33', '\x30']),
- ('\u325b', &['\x33', '\x31']), ('\u325c', &['\x33', '\x32']), ('\u325d', &['\x33', '\x33']),
- ('\u325e', &['\x33', '\x34']), ('\u325f', &['\x33', '\x35']), ('\u3260', &['\u1100']),
- ('\u3261', &['\u1102']), ('\u3262', &['\u1103']), ('\u3263', &['\u1105']), ('\u3264',
- &['\u1106']), ('\u3265', &['\u1107']), ('\u3266', &['\u1109']), ('\u3267', &['\u110b']),
- ('\u3268', &['\u110c']), ('\u3269', &['\u110e']), ('\u326a', &['\u110f']), ('\u326b',
- &['\u1110']), ('\u326c', &['\u1111']), ('\u326d', &['\u1112']), ('\u326e', &['\u1100',
- '\u1161']), ('\u326f', &['\u1102', '\u1161']), ('\u3270', &['\u1103', '\u1161']), ('\u3271',
- &['\u1105', '\u1161']), ('\u3272', &['\u1106', '\u1161']), ('\u3273', &['\u1107',
- '\u1161']), ('\u3274', &['\u1109', '\u1161']), ('\u3275', &['\u110b', '\u1161']), ('\u3276',
- &['\u110c', '\u1161']), ('\u3277', &['\u110e', '\u1161']), ('\u3278', &['\u110f',
- '\u1161']), ('\u3279', &['\u1110', '\u1161']), ('\u327a', &['\u1111', '\u1161']), ('\u327b',
- &['\u1112', '\u1161']), ('\u327c', &['\u110e', '\u1161', '\u11b7', '\u1100', '\u1169']),
- ('\u327d', &['\u110c', '\u116e', '\u110b', '\u1174']), ('\u327e', &['\u110b', '\u116e']),
- ('\u3280', &['\u4e00']), ('\u3281', &['\u4e8c']), ('\u3282', &['\u4e09']), ('\u3283',
- &['\u56db']), ('\u3284', &['\u4e94']), ('\u3285', &['\u516d']), ('\u3286', &['\u4e03']),
- ('\u3287', &['\u516b']), ('\u3288', &['\u4e5d']), ('\u3289', &['\u5341']), ('\u328a',
- &['\u6708']), ('\u328b', &['\u706b']), ('\u328c', &['\u6c34']), ('\u328d', &['\u6728']),
- ('\u328e', &['\u91d1']), ('\u328f', &['\u571f']), ('\u3290', &['\u65e5']), ('\u3291',
- &['\u682a']), ('\u3292', &['\u6709']), ('\u3293', &['\u793e']), ('\u3294', &['\u540d']),
- ('\u3295', &['\u7279']), ('\u3296', &['\u8ca1']), ('\u3297', &['\u795d']), ('\u3298',
- &['\u52b4']), ('\u3299', &['\u79d8']), ('\u329a', &['\u7537']), ('\u329b', &['\u5973']),
- ('\u329c', &['\u9069']), ('\u329d', &['\u512a']), ('\u329e', &['\u5370']), ('\u329f',
- &['\u6ce8']), ('\u32a0', &['\u9805']), ('\u32a1', &['\u4f11']), ('\u32a2', &['\u5199']),
- ('\u32a3', &['\u6b63']), ('\u32a4', &['\u4e0a']), ('\u32a5', &['\u4e2d']), ('\u32a6',
- &['\u4e0b']), ('\u32a7', &['\u5de6']), ('\u32a8', &['\u53f3']), ('\u32a9', &['\u533b']),
- ('\u32aa', &['\u5b97']), ('\u32ab', &['\u5b66']), ('\u32ac', &['\u76e3']), ('\u32ad',
- &['\u4f01']), ('\u32ae', &['\u8cc7']), ('\u32af', &['\u5354']), ('\u32b0', &['\u591c']),
- ('\u32b1', &['\x33', '\x36']), ('\u32b2', &['\x33', '\x37']), ('\u32b3', &['\x33', '\x38']),
- ('\u32b4', &['\x33', '\x39']), ('\u32b5', &['\x34', '\x30']), ('\u32b6', &['\x34', '\x31']),
- ('\u32b7', &['\x34', '\x32']), ('\u32b8', &['\x34', '\x33']), ('\u32b9', &['\x34', '\x34']),
- ('\u32ba', &['\x34', '\x35']), ('\u32bb', &['\x34', '\x36']), ('\u32bc', &['\x34', '\x37']),
- ('\u32bd', &['\x34', '\x38']), ('\u32be', &['\x34', '\x39']), ('\u32bf', &['\x35', '\x30']),
- ('\u32c0', &['\x31', '\u6708']), ('\u32c1', &['\x32', '\u6708']), ('\u32c2', &['\x33',
- '\u6708']), ('\u32c3', &['\x34', '\u6708']), ('\u32c4', &['\x35', '\u6708']), ('\u32c5',
- &['\x36', '\u6708']), ('\u32c6', &['\x37', '\u6708']), ('\u32c7', &['\x38', '\u6708']),
- ('\u32c8', &['\x39', '\u6708']), ('\u32c9', &['\x31', '\x30', '\u6708']), ('\u32ca',
- &['\x31', '\x31', '\u6708']), ('\u32cb', &['\x31', '\x32', '\u6708']), ('\u32cc', &['\x48',
- '\x67']), ('\u32cd', &['\x65', '\x72', '\x67']), ('\u32ce', &['\x65', '\x56']), ('\u32cf',
- &['\x4c', '\x54', '\x44']), ('\u32d0', &['\u30a2']), ('\u32d1', &['\u30a4']), ('\u32d2',
- &['\u30a6']), ('\u32d3', &['\u30a8']), ('\u32d4', &['\u30aa']), ('\u32d5', &['\u30ab']),
- ('\u32d6', &['\u30ad']), ('\u32d7', &['\u30af']), ('\u32d8', &['\u30b1']), ('\u32d9',
- &['\u30b3']), ('\u32da', &['\u30b5']), ('\u32db', &['\u30b7']), ('\u32dc', &['\u30b9']),
- ('\u32dd', &['\u30bb']), ('\u32de', &['\u30bd']), ('\u32df', &['\u30bf']), ('\u32e0',
- &['\u30c1']), ('\u32e1', &['\u30c4']), ('\u32e2', &['\u30c6']), ('\u32e3', &['\u30c8']),
- ('\u32e4', &['\u30ca']), ('\u32e5', &['\u30cb']), ('\u32e6', &['\u30cc']), ('\u32e7',
- &['\u30cd']), ('\u32e8', &['\u30ce']), ('\u32e9', &['\u30cf']), ('\u32ea', &['\u30d2']),
- ('\u32eb', &['\u30d5']), ('\u32ec', &['\u30d8']), ('\u32ed', &['\u30db']), ('\u32ee',
- &['\u30de']), ('\u32ef', &['\u30df']), ('\u32f0', &['\u30e0']), ('\u32f1', &['\u30e1']),
- ('\u32f2', &['\u30e2']), ('\u32f3', &['\u30e4']), ('\u32f4', &['\u30e6']), ('\u32f5',
- &['\u30e8']), ('\u32f6', &['\u30e9']), ('\u32f7', &['\u30ea']), ('\u32f8', &['\u30eb']),
- ('\u32f9', &['\u30ec']), ('\u32fa', &['\u30ed']), ('\u32fb', &['\u30ef']), ('\u32fc',
- &['\u30f0']), ('\u32fd', &['\u30f1']), ('\u32fe', &['\u30f2']), ('\u3300', &['\u30a2',
- '\u30d1', '\u30fc', '\u30c8']), ('\u3301', &['\u30a2', '\u30eb', '\u30d5', '\u30a1']),
- ('\u3302', &['\u30a2', '\u30f3', '\u30da', '\u30a2']), ('\u3303', &['\u30a2', '\u30fc',
- '\u30eb']), ('\u3304', &['\u30a4', '\u30cb', '\u30f3', '\u30b0']), ('\u3305', &['\u30a4',
- '\u30f3', '\u30c1']), ('\u3306', &['\u30a6', '\u30a9', '\u30f3']), ('\u3307', &['\u30a8',
- '\u30b9', '\u30af', '\u30fc', '\u30c9']), ('\u3308', &['\u30a8', '\u30fc', '\u30ab',
- '\u30fc']), ('\u3309', &['\u30aa', '\u30f3', '\u30b9']), ('\u330a', &['\u30aa', '\u30fc',
- '\u30e0']), ('\u330b', &['\u30ab', '\u30a4', '\u30ea']), ('\u330c', &['\u30ab', '\u30e9',
- '\u30c3', '\u30c8']), ('\u330d', &['\u30ab', '\u30ed', '\u30ea', '\u30fc']), ('\u330e',
- &['\u30ac', '\u30ed', '\u30f3']), ('\u330f', &['\u30ac', '\u30f3', '\u30de']), ('\u3310',
- &['\u30ae', '\u30ac']), ('\u3311', &['\u30ae', '\u30cb', '\u30fc']), ('\u3312', &['\u30ad',
- '\u30e5', '\u30ea', '\u30fc']), ('\u3313', &['\u30ae', '\u30eb', '\u30c0', '\u30fc']),
- ('\u3314', &['\u30ad', '\u30ed']), ('\u3315', &['\u30ad', '\u30ed', '\u30b0', '\u30e9',
- '\u30e0']), ('\u3316', &['\u30ad', '\u30ed', '\u30e1', '\u30fc', '\u30c8', '\u30eb']),
- ('\u3317', &['\u30ad', '\u30ed', '\u30ef', '\u30c3', '\u30c8']), ('\u3318', &['\u30b0',
- '\u30e9', '\u30e0']), ('\u3319', &['\u30b0', '\u30e9', '\u30e0', '\u30c8', '\u30f3']),
- ('\u331a', &['\u30af', '\u30eb', '\u30bc', '\u30a4', '\u30ed']), ('\u331b', &['\u30af',
- '\u30ed', '\u30fc', '\u30cd']), ('\u331c', &['\u30b1', '\u30fc', '\u30b9']), ('\u331d',
- &['\u30b3', '\u30eb', '\u30ca']), ('\u331e', &['\u30b3', '\u30fc', '\u30dd']), ('\u331f',
- &['\u30b5', '\u30a4', '\u30af', '\u30eb']), ('\u3320', &['\u30b5', '\u30f3', '\u30c1',
- '\u30fc', '\u30e0']), ('\u3321', &['\u30b7', '\u30ea', '\u30f3', '\u30b0']), ('\u3322',
- &['\u30bb', '\u30f3', '\u30c1']), ('\u3323', &['\u30bb', '\u30f3', '\u30c8']), ('\u3324',
- &['\u30c0', '\u30fc', '\u30b9']), ('\u3325', &['\u30c7', '\u30b7']), ('\u3326', &['\u30c9',
- '\u30eb']), ('\u3327', &['\u30c8', '\u30f3']), ('\u3328', &['\u30ca', '\u30ce']), ('\u3329',
- &['\u30ce', '\u30c3', '\u30c8']), ('\u332a', &['\u30cf', '\u30a4', '\u30c4']), ('\u332b',
- &['\u30d1', '\u30fc', '\u30bb', '\u30f3', '\u30c8']), ('\u332c', &['\u30d1', '\u30fc',
- '\u30c4']), ('\u332d', &['\u30d0', '\u30fc', '\u30ec', '\u30eb']), ('\u332e', &['\u30d4',
- '\u30a2', '\u30b9', '\u30c8', '\u30eb']), ('\u332f', &['\u30d4', '\u30af', '\u30eb']),
- ('\u3330', &['\u30d4', '\u30b3']), ('\u3331', &['\u30d3', '\u30eb']), ('\u3332', &['\u30d5',
- '\u30a1', '\u30e9', '\u30c3', '\u30c9']), ('\u3333', &['\u30d5', '\u30a3', '\u30fc',
- '\u30c8']), ('\u3334', &['\u30d6', '\u30c3', '\u30b7', '\u30a7', '\u30eb']), ('\u3335',
- &['\u30d5', '\u30e9', '\u30f3']), ('\u3336', &['\u30d8', '\u30af', '\u30bf', '\u30fc',
- '\u30eb']), ('\u3337', &['\u30da', '\u30bd']), ('\u3338', &['\u30da', '\u30cb', '\u30d2']),
- ('\u3339', &['\u30d8', '\u30eb', '\u30c4']), ('\u333a', &['\u30da', '\u30f3', '\u30b9']),
- ('\u333b', &['\u30da', '\u30fc', '\u30b8']), ('\u333c', &['\u30d9', '\u30fc', '\u30bf']),
- ('\u333d', &['\u30dd', '\u30a4', '\u30f3', '\u30c8']), ('\u333e', &['\u30dc', '\u30eb',
- '\u30c8']), ('\u333f', &['\u30db', '\u30f3']), ('\u3340', &['\u30dd', '\u30f3', '\u30c9']),
- ('\u3341', &['\u30db', '\u30fc', '\u30eb']), ('\u3342', &['\u30db', '\u30fc', '\u30f3']),
- ('\u3343', &['\u30de', '\u30a4', '\u30af', '\u30ed']), ('\u3344', &['\u30de', '\u30a4',
- '\u30eb']), ('\u3345', &['\u30de', '\u30c3', '\u30cf']), ('\u3346', &['\u30de', '\u30eb',
- '\u30af']), ('\u3347', &['\u30de', '\u30f3', '\u30b7', '\u30e7', '\u30f3']), ('\u3348',
- &['\u30df', '\u30af', '\u30ed', '\u30f3']), ('\u3349', &['\u30df', '\u30ea']), ('\u334a',
- &['\u30df', '\u30ea', '\u30d0', '\u30fc', '\u30eb']), ('\u334b', &['\u30e1', '\u30ac']),
- ('\u334c', &['\u30e1', '\u30ac', '\u30c8', '\u30f3']), ('\u334d', &['\u30e1', '\u30fc',
- '\u30c8', '\u30eb']), ('\u334e', &['\u30e4', '\u30fc', '\u30c9']), ('\u334f', &['\u30e4',
- '\u30fc', '\u30eb']), ('\u3350', &['\u30e6', '\u30a2', '\u30f3']), ('\u3351', &['\u30ea',
- '\u30c3', '\u30c8', '\u30eb']), ('\u3352', &['\u30ea', '\u30e9']), ('\u3353', &['\u30eb',
- '\u30d4', '\u30fc']), ('\u3354', &['\u30eb', '\u30fc', '\u30d6', '\u30eb']), ('\u3355',
- &['\u30ec', '\u30e0']), ('\u3356', &['\u30ec', '\u30f3', '\u30c8', '\u30b2', '\u30f3']),
- ('\u3357', &['\u30ef', '\u30c3', '\u30c8']), ('\u3358', &['\x30', '\u70b9']), ('\u3359',
- &['\x31', '\u70b9']), ('\u335a', &['\x32', '\u70b9']), ('\u335b', &['\x33', '\u70b9']),
- ('\u335c', &['\x34', '\u70b9']), ('\u335d', &['\x35', '\u70b9']), ('\u335e', &['\x36',
- '\u70b9']), ('\u335f', &['\x37', '\u70b9']), ('\u3360', &['\x38', '\u70b9']), ('\u3361',
- &['\x39', '\u70b9']), ('\u3362', &['\x31', '\x30', '\u70b9']), ('\u3363', &['\x31', '\x31',
- '\u70b9']), ('\u3364', &['\x31', '\x32', '\u70b9']), ('\u3365', &['\x31', '\x33',
- '\u70b9']), ('\u3366', &['\x31', '\x34', '\u70b9']), ('\u3367', &['\x31', '\x35',
- '\u70b9']), ('\u3368', &['\x31', '\x36', '\u70b9']), ('\u3369', &['\x31', '\x37',
- '\u70b9']), ('\u336a', &['\x31', '\x38', '\u70b9']), ('\u336b', &['\x31', '\x39',
- '\u70b9']), ('\u336c', &['\x32', '\x30', '\u70b9']), ('\u336d', &['\x32', '\x31',
- '\u70b9']), ('\u336e', &['\x32', '\x32', '\u70b9']), ('\u336f', &['\x32', '\x33',
- '\u70b9']), ('\u3370', &['\x32', '\x34', '\u70b9']), ('\u3371', &['\x68', '\x50', '\x61']),
- ('\u3372', &['\x64', '\x61']), ('\u3373', &['\x41', '\x55']), ('\u3374', &['\x62', '\x61',
- '\x72']), ('\u3375', &['\x6f', '\x56']), ('\u3376', &['\x70', '\x63']), ('\u3377', &['\x64',
- '\x6d']), ('\u3378', &['\x64', '\x6d', '\xb2']), ('\u3379', &['\x64', '\x6d', '\xb3']),
- ('\u337a', &['\x49', '\x55']), ('\u337b', &['\u5e73', '\u6210']), ('\u337c', &['\u662d',
- '\u548c']), ('\u337d', &['\u5927', '\u6b63']), ('\u337e', &['\u660e', '\u6cbb']), ('\u337f',
- &['\u682a', '\u5f0f', '\u4f1a', '\u793e']), ('\u3380', &['\x70', '\x41']), ('\u3381',
- &['\x6e', '\x41']), ('\u3382', &['\u03bc', '\x41']), ('\u3383', &['\x6d', '\x41']),
- ('\u3384', &['\x6b', '\x41']), ('\u3385', &['\x4b', '\x42']), ('\u3386', &['\x4d', '\x42']),
- ('\u3387', &['\x47', '\x42']), ('\u3388', &['\x63', '\x61', '\x6c']), ('\u3389', &['\x6b',
- '\x63', '\x61', '\x6c']), ('\u338a', &['\x70', '\x46']), ('\u338b', &['\x6e', '\x46']),
- ('\u338c', &['\u03bc', '\x46']), ('\u338d', &['\u03bc', '\x67']), ('\u338e', &['\x6d',
- '\x67']), ('\u338f', &['\x6b', '\x67']), ('\u3390', &['\x48', '\x7a']), ('\u3391', &['\x6b',
- '\x48', '\x7a']), ('\u3392', &['\x4d', '\x48', '\x7a']), ('\u3393', &['\x47', '\x48',
- '\x7a']), ('\u3394', &['\x54', '\x48', '\x7a']), ('\u3395', &['\u03bc', '\u2113']),
- ('\u3396', &['\x6d', '\u2113']), ('\u3397', &['\x64', '\u2113']), ('\u3398', &['\x6b',
- '\u2113']), ('\u3399', &['\x66', '\x6d']), ('\u339a', &['\x6e', '\x6d']), ('\u339b',
- &['\u03bc', '\x6d']), ('\u339c', &['\x6d', '\x6d']), ('\u339d', &['\x63', '\x6d']),
- ('\u339e', &['\x6b', '\x6d']), ('\u339f', &['\x6d', '\x6d', '\xb2']), ('\u33a0', &['\x63',
- '\x6d', '\xb2']), ('\u33a1', &['\x6d', '\xb2']), ('\u33a2', &['\x6b', '\x6d', '\xb2']),
- ('\u33a3', &['\x6d', '\x6d', '\xb3']), ('\u33a4', &['\x63', '\x6d', '\xb3']), ('\u33a5',
- &['\x6d', '\xb3']), ('\u33a6', &['\x6b', '\x6d', '\xb3']), ('\u33a7', &['\x6d', '\u2215',
- '\x73']), ('\u33a8', &['\x6d', '\u2215', '\x73', '\xb2']), ('\u33a9', &['\x50', '\x61']),
- ('\u33aa', &['\x6b', '\x50', '\x61']), ('\u33ab', &['\x4d', '\x50', '\x61']), ('\u33ac',
- &['\x47', '\x50', '\x61']), ('\u33ad', &['\x72', '\x61', '\x64']), ('\u33ae', &['\x72',
- '\x61', '\x64', '\u2215', '\x73']), ('\u33af', &['\x72', '\x61', '\x64', '\u2215', '\x73',
- '\xb2']), ('\u33b0', &['\x70', '\x73']), ('\u33b1', &['\x6e', '\x73']), ('\u33b2',
- &['\u03bc', '\x73']), ('\u33b3', &['\x6d', '\x73']), ('\u33b4', &['\x70', '\x56']),
- ('\u33b5', &['\x6e', '\x56']), ('\u33b6', &['\u03bc', '\x56']), ('\u33b7', &['\x6d',
- '\x56']), ('\u33b8', &['\x6b', '\x56']), ('\u33b9', &['\x4d', '\x56']), ('\u33ba', &['\x70',
- '\x57']), ('\u33bb', &['\x6e', '\x57']), ('\u33bc', &['\u03bc', '\x57']), ('\u33bd',
- &['\x6d', '\x57']), ('\u33be', &['\x6b', '\x57']), ('\u33bf', &['\x4d', '\x57']), ('\u33c0',
- &['\x6b', '\u03a9']), ('\u33c1', &['\x4d', '\u03a9']), ('\u33c2', &['\x61', '\x2e', '\x6d',
- '\x2e']), ('\u33c3', &['\x42', '\x71']), ('\u33c4', &['\x63', '\x63']), ('\u33c5', &['\x63',
- '\x64']), ('\u33c6', &['\x43', '\u2215', '\x6b', '\x67']), ('\u33c7', &['\x43', '\x6f',
- '\x2e']), ('\u33c8', &['\x64', '\x42']), ('\u33c9', &['\x47', '\x79']), ('\u33ca', &['\x68',
- '\x61']), ('\u33cb', &['\x48', '\x50']), ('\u33cc', &['\x69', '\x6e']), ('\u33cd', &['\x4b',
- '\x4b']), ('\u33ce', &['\x4b', '\x4d']), ('\u33cf', &['\x6b', '\x74']), ('\u33d0', &['\x6c',
- '\x6d']), ('\u33d1', &['\x6c', '\x6e']), ('\u33d2', &['\x6c', '\x6f', '\x67']), ('\u33d3',
- &['\x6c', '\x78']), ('\u33d4', &['\x6d', '\x62']), ('\u33d5', &['\x6d', '\x69', '\x6c']),
- ('\u33d6', &['\x6d', '\x6f', '\x6c']), ('\u33d7', &['\x50', '\x48']), ('\u33d8', &['\x70',
- '\x2e', '\x6d', '\x2e']), ('\u33d9', &['\x50', '\x50', '\x4d']), ('\u33da', &['\x50',
- '\x52']), ('\u33db', &['\x73', '\x72']), ('\u33dc', &['\x53', '\x76']), ('\u33dd', &['\x57',
- '\x62']), ('\u33de', &['\x56', '\u2215', '\x6d']), ('\u33df', &['\x41', '\u2215', '\x6d']),
- ('\u33e0', &['\x31', '\u65e5']), ('\u33e1', &['\x32', '\u65e5']), ('\u33e2', &['\x33',
- '\u65e5']), ('\u33e3', &['\x34', '\u65e5']), ('\u33e4', &['\x35', '\u65e5']), ('\u33e5',
- &['\x36', '\u65e5']), ('\u33e6', &['\x37', '\u65e5']), ('\u33e7', &['\x38', '\u65e5']),
- ('\u33e8', &['\x39', '\u65e5']), ('\u33e9', &['\x31', '\x30', '\u65e5']), ('\u33ea',
- &['\x31', '\x31', '\u65e5']), ('\u33eb', &['\x31', '\x32', '\u65e5']), ('\u33ec', &['\x31',
- '\x33', '\u65e5']), ('\u33ed', &['\x31', '\x34', '\u65e5']), ('\u33ee', &['\x31', '\x35',
- '\u65e5']), ('\u33ef', &['\x31', '\x36', '\u65e5']), ('\u33f0', &['\x31', '\x37',
- '\u65e5']), ('\u33f1', &['\x31', '\x38', '\u65e5']), ('\u33f2', &['\x31', '\x39',
- '\u65e5']), ('\u33f3', &['\x32', '\x30', '\u65e5']), ('\u33f4', &['\x32', '\x31',
- '\u65e5']), ('\u33f5', &['\x32', '\x32', '\u65e5']), ('\u33f6', &['\x32', '\x33',
- '\u65e5']), ('\u33f7', &['\x32', '\x34', '\u65e5']), ('\u33f8', &['\x32', '\x35',
- '\u65e5']), ('\u33f9', &['\x32', '\x36', '\u65e5']), ('\u33fa', &['\x32', '\x37',
- '\u65e5']), ('\u33fb', &['\x32', '\x38', '\u65e5']), ('\u33fc', &['\x32', '\x39',
- '\u65e5']), ('\u33fd', &['\x33', '\x30', '\u65e5']), ('\u33fe', &['\x33', '\x31',
- '\u65e5']), ('\u33ff', &['\x67', '\x61', '\x6c']), ('\ua770', &['\ua76f']), ('\ua7f8',
- &['\u0126']), ('\ua7f9', &['\u0153']), ('\ufb00', &['\x66', '\x66']), ('\ufb01', &['\x66',
- '\x69']), ('\ufb02', &['\x66', '\x6c']), ('\ufb03', &['\x66', '\x66', '\x69']), ('\ufb04',
- &['\x66', '\x66', '\x6c']), ('\ufb05', &['\u017f', '\x74']), ('\ufb06', &['\x73', '\x74']),
- ('\ufb13', &['\u0574', '\u0576']), ('\ufb14', &['\u0574', '\u0565']), ('\ufb15', &['\u0574',
- '\u056b']), ('\ufb16', &['\u057e', '\u0576']), ('\ufb17', &['\u0574', '\u056d']), ('\ufb20',
- &['\u05e2']), ('\ufb21', &['\u05d0']), ('\ufb22', &['\u05d3']), ('\ufb23', &['\u05d4']),
- ('\ufb24', &['\u05db']), ('\ufb25', &['\u05dc']), ('\ufb26', &['\u05dd']), ('\ufb27',
- &['\u05e8']), ('\ufb28', &['\u05ea']), ('\ufb29', &['\x2b']), ('\ufb4f', &['\u05d0',
- '\u05dc']), ('\ufb50', &['\u0671']), ('\ufb51', &['\u0671']), ('\ufb52', &['\u067b']),
- ('\ufb53', &['\u067b']), ('\ufb54', &['\u067b']), ('\ufb55', &['\u067b']), ('\ufb56',
- &['\u067e']), ('\ufb57', &['\u067e']), ('\ufb58', &['\u067e']), ('\ufb59', &['\u067e']),
- ('\ufb5a', &['\u0680']), ('\ufb5b', &['\u0680']), ('\ufb5c', &['\u0680']), ('\ufb5d',
- &['\u0680']), ('\ufb5e', &['\u067a']), ('\ufb5f', &['\u067a']), ('\ufb60', &['\u067a']),
- ('\ufb61', &['\u067a']), ('\ufb62', &['\u067f']), ('\ufb63', &['\u067f']), ('\ufb64',
- &['\u067f']), ('\ufb65', &['\u067f']), ('\ufb66', &['\u0679']), ('\ufb67', &['\u0679']),
- ('\ufb68', &['\u0679']), ('\ufb69', &['\u0679']), ('\ufb6a', &['\u06a4']), ('\ufb6b',
- &['\u06a4']), ('\ufb6c', &['\u06a4']), ('\ufb6d', &['\u06a4']), ('\ufb6e', &['\u06a6']),
- ('\ufb6f', &['\u06a6']), ('\ufb70', &['\u06a6']), ('\ufb71', &['\u06a6']), ('\ufb72',
- &['\u0684']), ('\ufb73', &['\u0684']), ('\ufb74', &['\u0684']), ('\ufb75', &['\u0684']),
- ('\ufb76', &['\u0683']), ('\ufb77', &['\u0683']), ('\ufb78', &['\u0683']), ('\ufb79',
- &['\u0683']), ('\ufb7a', &['\u0686']), ('\ufb7b', &['\u0686']), ('\ufb7c', &['\u0686']),
- ('\ufb7d', &['\u0686']), ('\ufb7e', &['\u0687']), ('\ufb7f', &['\u0687']), ('\ufb80',
- &['\u0687']), ('\ufb81', &['\u0687']), ('\ufb82', &['\u068d']), ('\ufb83', &['\u068d']),
- ('\ufb84', &['\u068c']), ('\ufb85', &['\u068c']), ('\ufb86', &['\u068e']), ('\ufb87',
- &['\u068e']), ('\ufb88', &['\u0688']), ('\ufb89', &['\u0688']), ('\ufb8a', &['\u0698']),
- ('\ufb8b', &['\u0698']), ('\ufb8c', &['\u0691']), ('\ufb8d', &['\u0691']), ('\ufb8e',
- &['\u06a9']), ('\ufb8f', &['\u06a9']), ('\ufb90', &['\u06a9']), ('\ufb91', &['\u06a9']),
- ('\ufb92', &['\u06af']), ('\ufb93', &['\u06af']), ('\ufb94', &['\u06af']), ('\ufb95',
- &['\u06af']), ('\ufb96', &['\u06b3']), ('\ufb97', &['\u06b3']), ('\ufb98', &['\u06b3']),
- ('\ufb99', &['\u06b3']), ('\ufb9a', &['\u06b1']), ('\ufb9b', &['\u06b1']), ('\ufb9c',
- &['\u06b1']), ('\ufb9d', &['\u06b1']), ('\ufb9e', &['\u06ba']), ('\ufb9f', &['\u06ba']),
- ('\ufba0', &['\u06bb']), ('\ufba1', &['\u06bb']), ('\ufba2', &['\u06bb']), ('\ufba3',
- &['\u06bb']), ('\ufba4', &['\u06c0']), ('\ufba5', &['\u06c0']), ('\ufba6', &['\u06c1']),
- ('\ufba7', &['\u06c1']), ('\ufba8', &['\u06c1']), ('\ufba9', &['\u06c1']), ('\ufbaa',
- &['\u06be']), ('\ufbab', &['\u06be']), ('\ufbac', &['\u06be']), ('\ufbad', &['\u06be']),
- ('\ufbae', &['\u06d2']), ('\ufbaf', &['\u06d2']), ('\ufbb0', &['\u06d3']), ('\ufbb1',
- &['\u06d3']), ('\ufbd3', &['\u06ad']), ('\ufbd4', &['\u06ad']), ('\ufbd5', &['\u06ad']),
- ('\ufbd6', &['\u06ad']), ('\ufbd7', &['\u06c7']), ('\ufbd8', &['\u06c7']), ('\ufbd9',
- &['\u06c6']), ('\ufbda', &['\u06c6']), ('\ufbdb', &['\u06c8']), ('\ufbdc', &['\u06c8']),
- ('\ufbdd', &['\u0677']), ('\ufbde', &['\u06cb']), ('\ufbdf', &['\u06cb']), ('\ufbe0',
- &['\u06c5']), ('\ufbe1', &['\u06c5']), ('\ufbe2', &['\u06c9']), ('\ufbe3', &['\u06c9']),
- ('\ufbe4', &['\u06d0']), ('\ufbe5', &['\u06d0']), ('\ufbe6', &['\u06d0']), ('\ufbe7',
- &['\u06d0']), ('\ufbe8', &['\u0649']), ('\ufbe9', &['\u0649']), ('\ufbea', &['\u0626',
- '\u0627']), ('\ufbeb', &['\u0626', '\u0627']), ('\ufbec', &['\u0626', '\u06d5']), ('\ufbed',
- &['\u0626', '\u06d5']), ('\ufbee', &['\u0626', '\u0648']), ('\ufbef', &['\u0626',
- '\u0648']), ('\ufbf0', &['\u0626', '\u06c7']), ('\ufbf1', &['\u0626', '\u06c7']), ('\ufbf2',
- &['\u0626', '\u06c6']), ('\ufbf3', &['\u0626', '\u06c6']), ('\ufbf4', &['\u0626',
- '\u06c8']), ('\ufbf5', &['\u0626', '\u06c8']), ('\ufbf6', &['\u0626', '\u06d0']), ('\ufbf7',
- &['\u0626', '\u06d0']), ('\ufbf8', &['\u0626', '\u06d0']), ('\ufbf9', &['\u0626',
- '\u0649']), ('\ufbfa', &['\u0626', '\u0649']), ('\ufbfb', &['\u0626', '\u0649']), ('\ufbfc',
- &['\u06cc']), ('\ufbfd', &['\u06cc']), ('\ufbfe', &['\u06cc']), ('\ufbff', &['\u06cc']),
- ('\ufc00', &['\u0626', '\u062c']), ('\ufc01', &['\u0626', '\u062d']), ('\ufc02', &['\u0626',
- '\u0645']), ('\ufc03', &['\u0626', '\u0649']), ('\ufc04', &['\u0626', '\u064a']), ('\ufc05',
- &['\u0628', '\u062c']), ('\ufc06', &['\u0628', '\u062d']), ('\ufc07', &['\u0628',
- '\u062e']), ('\ufc08', &['\u0628', '\u0645']), ('\ufc09', &['\u0628', '\u0649']), ('\ufc0a',
- &['\u0628', '\u064a']), ('\ufc0b', &['\u062a', '\u062c']), ('\ufc0c', &['\u062a',
- '\u062d']), ('\ufc0d', &['\u062a', '\u062e']), ('\ufc0e', &['\u062a', '\u0645']), ('\ufc0f',
- &['\u062a', '\u0649']), ('\ufc10', &['\u062a', '\u064a']), ('\ufc11', &['\u062b',
- '\u062c']), ('\ufc12', &['\u062b', '\u0645']), ('\ufc13', &['\u062b', '\u0649']), ('\ufc14',
- &['\u062b', '\u064a']), ('\ufc15', &['\u062c', '\u062d']), ('\ufc16', &['\u062c',
- '\u0645']), ('\ufc17', &['\u062d', '\u062c']), ('\ufc18', &['\u062d', '\u0645']), ('\ufc19',
- &['\u062e', '\u062c']), ('\ufc1a', &['\u062e', '\u062d']), ('\ufc1b', &['\u062e',
- '\u0645']), ('\ufc1c', &['\u0633', '\u062c']), ('\ufc1d', &['\u0633', '\u062d']), ('\ufc1e',
- &['\u0633', '\u062e']), ('\ufc1f', &['\u0633', '\u0645']), ('\ufc20', &['\u0635',
- '\u062d']), ('\ufc21', &['\u0635', '\u0645']), ('\ufc22', &['\u0636', '\u062c']), ('\ufc23',
- &['\u0636', '\u062d']), ('\ufc24', &['\u0636', '\u062e']), ('\ufc25', &['\u0636',
- '\u0645']), ('\ufc26', &['\u0637', '\u062d']), ('\ufc27', &['\u0637', '\u0645']), ('\ufc28',
- &['\u0638', '\u0645']), ('\ufc29', &['\u0639', '\u062c']), ('\ufc2a', &['\u0639',
- '\u0645']), ('\ufc2b', &['\u063a', '\u062c']), ('\ufc2c', &['\u063a', '\u0645']), ('\ufc2d',
- &['\u0641', '\u062c']), ('\ufc2e', &['\u0641', '\u062d']), ('\ufc2f', &['\u0641',
- '\u062e']), ('\ufc30', &['\u0641', '\u0645']), ('\ufc31', &['\u0641', '\u0649']), ('\ufc32',
- &['\u0641', '\u064a']), ('\ufc33', &['\u0642', '\u062d']), ('\ufc34', &['\u0642',
- '\u0645']), ('\ufc35', &['\u0642', '\u0649']), ('\ufc36', &['\u0642', '\u064a']), ('\ufc37',
- &['\u0643', '\u0627']), ('\ufc38', &['\u0643', '\u062c']), ('\ufc39', &['\u0643',
- '\u062d']), ('\ufc3a', &['\u0643', '\u062e']), ('\ufc3b', &['\u0643', '\u0644']), ('\ufc3c',
- &['\u0643', '\u0645']), ('\ufc3d', &['\u0643', '\u0649']), ('\ufc3e', &['\u0643',
- '\u064a']), ('\ufc3f', &['\u0644', '\u062c']), ('\ufc40', &['\u0644', '\u062d']), ('\ufc41',
- &['\u0644', '\u062e']), ('\ufc42', &['\u0644', '\u0645']), ('\ufc43', &['\u0644',
- '\u0649']), ('\ufc44', &['\u0644', '\u064a']), ('\ufc45', &['\u0645', '\u062c']), ('\ufc46',
- &['\u0645', '\u062d']), ('\ufc47', &['\u0645', '\u062e']), ('\ufc48', &['\u0645',
- '\u0645']), ('\ufc49', &['\u0645', '\u0649']), ('\ufc4a', &['\u0645', '\u064a']), ('\ufc4b',
- &['\u0646', '\u062c']), ('\ufc4c', &['\u0646', '\u062d']), ('\ufc4d', &['\u0646',
- '\u062e']), ('\ufc4e', &['\u0646', '\u0645']), ('\ufc4f', &['\u0646', '\u0649']), ('\ufc50',
- &['\u0646', '\u064a']), ('\ufc51', &['\u0647', '\u062c']), ('\ufc52', &['\u0647',
- '\u0645']), ('\ufc53', &['\u0647', '\u0649']), ('\ufc54', &['\u0647', '\u064a']), ('\ufc55',
- &['\u064a', '\u062c']), ('\ufc56', &['\u064a', '\u062d']), ('\ufc57', &['\u064a',
- '\u062e']), ('\ufc58', &['\u064a', '\u0645']), ('\ufc59', &['\u064a', '\u0649']), ('\ufc5a',
- &['\u064a', '\u064a']), ('\ufc5b', &['\u0630', '\u0670']), ('\ufc5c', &['\u0631',
- '\u0670']), ('\ufc5d', &['\u0649', '\u0670']), ('\ufc5e', &['\x20', '\u064c', '\u0651']),
- ('\ufc5f', &['\x20', '\u064d', '\u0651']), ('\ufc60', &['\x20', '\u064e', '\u0651']),
- ('\ufc61', &['\x20', '\u064f', '\u0651']), ('\ufc62', &['\x20', '\u0650', '\u0651']),
- ('\ufc63', &['\x20', '\u0651', '\u0670']), ('\ufc64', &['\u0626', '\u0631']), ('\ufc65',
- &['\u0626', '\u0632']), ('\ufc66', &['\u0626', '\u0645']), ('\ufc67', &['\u0626',
- '\u0646']), ('\ufc68', &['\u0626', '\u0649']), ('\ufc69', &['\u0626', '\u064a']), ('\ufc6a',
- &['\u0628', '\u0631']), ('\ufc6b', &['\u0628', '\u0632']), ('\ufc6c', &['\u0628',
- '\u0645']), ('\ufc6d', &['\u0628', '\u0646']), ('\ufc6e', &['\u0628', '\u0649']), ('\ufc6f',
- &['\u0628', '\u064a']), ('\ufc70', &['\u062a', '\u0631']), ('\ufc71', &['\u062a',
- '\u0632']), ('\ufc72', &['\u062a', '\u0645']), ('\ufc73', &['\u062a', '\u0646']), ('\ufc74',
- &['\u062a', '\u0649']), ('\ufc75', &['\u062a', '\u064a']), ('\ufc76', &['\u062b',
- '\u0631']), ('\ufc77', &['\u062b', '\u0632']), ('\ufc78', &['\u062b', '\u0645']), ('\ufc79',
- &['\u062b', '\u0646']), ('\ufc7a', &['\u062b', '\u0649']), ('\ufc7b', &['\u062b',
- '\u064a']), ('\ufc7c', &['\u0641', '\u0649']), ('\ufc7d', &['\u0641', '\u064a']), ('\ufc7e',
- &['\u0642', '\u0649']), ('\ufc7f', &['\u0642', '\u064a']), ('\ufc80', &['\u0643',
- '\u0627']), ('\ufc81', &['\u0643', '\u0644']), ('\ufc82', &['\u0643', '\u0645']), ('\ufc83',
- &['\u0643', '\u0649']), ('\ufc84', &['\u0643', '\u064a']), ('\ufc85', &['\u0644',
- '\u0645']), ('\ufc86', &['\u0644', '\u0649']), ('\ufc87', &['\u0644', '\u064a']), ('\ufc88',
- &['\u0645', '\u0627']), ('\ufc89', &['\u0645', '\u0645']), ('\ufc8a', &['\u0646',
- '\u0631']), ('\ufc8b', &['\u0646', '\u0632']), ('\ufc8c', &['\u0646', '\u0645']), ('\ufc8d',
- &['\u0646', '\u0646']), ('\ufc8e', &['\u0646', '\u0649']), ('\ufc8f', &['\u0646',
- '\u064a']), ('\ufc90', &['\u0649', '\u0670']), ('\ufc91', &['\u064a', '\u0631']), ('\ufc92',
- &['\u064a', '\u0632']), ('\ufc93', &['\u064a', '\u0645']), ('\ufc94', &['\u064a',
- '\u0646']), ('\ufc95', &['\u064a', '\u0649']), ('\ufc96', &['\u064a', '\u064a']), ('\ufc97',
- &['\u0626', '\u062c']), ('\ufc98', &['\u0626', '\u062d']), ('\ufc99', &['\u0626',
- '\u062e']), ('\ufc9a', &['\u0626', '\u0645']), ('\ufc9b', &['\u0626', '\u0647']), ('\ufc9c',
- &['\u0628', '\u062c']), ('\ufc9d', &['\u0628', '\u062d']), ('\ufc9e', &['\u0628',
- '\u062e']), ('\ufc9f', &['\u0628', '\u0645']), ('\ufca0', &['\u0628', '\u0647']), ('\ufca1',
- &['\u062a', '\u062c']), ('\ufca2', &['\u062a', '\u062d']), ('\ufca3', &['\u062a',
- '\u062e']), ('\ufca4', &['\u062a', '\u0645']), ('\ufca5', &['\u062a', '\u0647']), ('\ufca6',
- &['\u062b', '\u0645']), ('\ufca7', &['\u062c', '\u062d']), ('\ufca8', &['\u062c',
- '\u0645']), ('\ufca9', &['\u062d', '\u062c']), ('\ufcaa', &['\u062d', '\u0645']), ('\ufcab',
- &['\u062e', '\u062c']), ('\ufcac', &['\u062e', '\u0645']), ('\ufcad', &['\u0633',
- '\u062c']), ('\ufcae', &['\u0633', '\u062d']), ('\ufcaf', &['\u0633', '\u062e']), ('\ufcb0',
- &['\u0633', '\u0645']), ('\ufcb1', &['\u0635', '\u062d']), ('\ufcb2', &['\u0635',
- '\u062e']), ('\ufcb3', &['\u0635', '\u0645']), ('\ufcb4', &['\u0636', '\u062c']), ('\ufcb5',
- &['\u0636', '\u062d']), ('\ufcb6', &['\u0636', '\u062e']), ('\ufcb7', &['\u0636',
- '\u0645']), ('\ufcb8', &['\u0637', '\u062d']), ('\ufcb9', &['\u0638', '\u0645']), ('\ufcba',
- &['\u0639', '\u062c']), ('\ufcbb', &['\u0639', '\u0645']), ('\ufcbc', &['\u063a',
- '\u062c']), ('\ufcbd', &['\u063a', '\u0645']), ('\ufcbe', &['\u0641', '\u062c']), ('\ufcbf',
- &['\u0641', '\u062d']), ('\ufcc0', &['\u0641', '\u062e']), ('\ufcc1', &['\u0641',
- '\u0645']), ('\ufcc2', &['\u0642', '\u062d']), ('\ufcc3', &['\u0642', '\u0645']), ('\ufcc4',
- &['\u0643', '\u062c']), ('\ufcc5', &['\u0643', '\u062d']), ('\ufcc6', &['\u0643',
- '\u062e']), ('\ufcc7', &['\u0643', '\u0644']), ('\ufcc8', &['\u0643', '\u0645']), ('\ufcc9',
- &['\u0644', '\u062c']), ('\ufcca', &['\u0644', '\u062d']), ('\ufccb', &['\u0644',
- '\u062e']), ('\ufccc', &['\u0644', '\u0645']), ('\ufccd', &['\u0644', '\u0647']), ('\ufcce',
- &['\u0645', '\u062c']), ('\ufccf', &['\u0645', '\u062d']), ('\ufcd0', &['\u0645',
- '\u062e']), ('\ufcd1', &['\u0645', '\u0645']), ('\ufcd2', &['\u0646', '\u062c']), ('\ufcd3',
- &['\u0646', '\u062d']), ('\ufcd4', &['\u0646', '\u062e']), ('\ufcd5', &['\u0646',
- '\u0645']), ('\ufcd6', &['\u0646', '\u0647']), ('\ufcd7', &['\u0647', '\u062c']), ('\ufcd8',
- &['\u0647', '\u0645']), ('\ufcd9', &['\u0647', '\u0670']), ('\ufcda', &['\u064a',
- '\u062c']), ('\ufcdb', &['\u064a', '\u062d']), ('\ufcdc', &['\u064a', '\u062e']), ('\ufcdd',
- &['\u064a', '\u0645']), ('\ufcde', &['\u064a', '\u0647']), ('\ufcdf', &['\u0626',
- '\u0645']), ('\ufce0', &['\u0626', '\u0647']), ('\ufce1', &['\u0628', '\u0645']), ('\ufce2',
- &['\u0628', '\u0647']), ('\ufce3', &['\u062a', '\u0645']), ('\ufce4', &['\u062a',
- '\u0647']), ('\ufce5', &['\u062b', '\u0645']), ('\ufce6', &['\u062b', '\u0647']), ('\ufce7',
- &['\u0633', '\u0645']), ('\ufce8', &['\u0633', '\u0647']), ('\ufce9', &['\u0634',
- '\u0645']), ('\ufcea', &['\u0634', '\u0647']), ('\ufceb', &['\u0643', '\u0644']), ('\ufcec',
- &['\u0643', '\u0645']), ('\ufced', &['\u0644', '\u0645']), ('\ufcee', &['\u0646',
- '\u0645']), ('\ufcef', &['\u0646', '\u0647']), ('\ufcf0', &['\u064a', '\u0645']), ('\ufcf1',
- &['\u064a', '\u0647']), ('\ufcf2', &['\u0640', '\u064e', '\u0651']), ('\ufcf3', &['\u0640',
- '\u064f', '\u0651']), ('\ufcf4', &['\u0640', '\u0650', '\u0651']), ('\ufcf5', &['\u0637',
- '\u0649']), ('\ufcf6', &['\u0637', '\u064a']), ('\ufcf7', &['\u0639', '\u0649']), ('\ufcf8',
- &['\u0639', '\u064a']), ('\ufcf9', &['\u063a', '\u0649']), ('\ufcfa', &['\u063a',
- '\u064a']), ('\ufcfb', &['\u0633', '\u0649']), ('\ufcfc', &['\u0633', '\u064a']), ('\ufcfd',
- &['\u0634', '\u0649']), ('\ufcfe', &['\u0634', '\u064a']), ('\ufcff', &['\u062d',
- '\u0649']), ('\ufd00', &['\u062d', '\u064a']), ('\ufd01', &['\u062c', '\u0649']), ('\ufd02',
- &['\u062c', '\u064a']), ('\ufd03', &['\u062e', '\u0649']), ('\ufd04', &['\u062e',
- '\u064a']), ('\ufd05', &['\u0635', '\u0649']), ('\ufd06', &['\u0635', '\u064a']), ('\ufd07',
- &['\u0636', '\u0649']), ('\ufd08', &['\u0636', '\u064a']), ('\ufd09', &['\u0634',
- '\u062c']), ('\ufd0a', &['\u0634', '\u062d']), ('\ufd0b', &['\u0634', '\u062e']), ('\ufd0c',
- &['\u0634', '\u0645']), ('\ufd0d', &['\u0634', '\u0631']), ('\ufd0e', &['\u0633',
- '\u0631']), ('\ufd0f', &['\u0635', '\u0631']), ('\ufd10', &['\u0636', '\u0631']), ('\ufd11',
- &['\u0637', '\u0649']), ('\ufd12', &['\u0637', '\u064a']), ('\ufd13', &['\u0639',
- '\u0649']), ('\ufd14', &['\u0639', '\u064a']), ('\ufd15', &['\u063a', '\u0649']), ('\ufd16',
- &['\u063a', '\u064a']), ('\ufd17', &['\u0633', '\u0649']), ('\ufd18', &['\u0633',
- '\u064a']), ('\ufd19', &['\u0634', '\u0649']), ('\ufd1a', &['\u0634', '\u064a']), ('\ufd1b',
- &['\u062d', '\u0649']), ('\ufd1c', &['\u062d', '\u064a']), ('\ufd1d', &['\u062c',
- '\u0649']), ('\ufd1e', &['\u062c', '\u064a']), ('\ufd1f', &['\u062e', '\u0649']), ('\ufd20',
- &['\u062e', '\u064a']), ('\ufd21', &['\u0635', '\u0649']), ('\ufd22', &['\u0635',
- '\u064a']), ('\ufd23', &['\u0636', '\u0649']), ('\ufd24', &['\u0636', '\u064a']), ('\ufd25',
- &['\u0634', '\u062c']), ('\ufd26', &['\u0634', '\u062d']), ('\ufd27', &['\u0634',
- '\u062e']), ('\ufd28', &['\u0634', '\u0645']), ('\ufd29', &['\u0634', '\u0631']), ('\ufd2a',
- &['\u0633', '\u0631']), ('\ufd2b', &['\u0635', '\u0631']), ('\ufd2c', &['\u0636',
- '\u0631']), ('\ufd2d', &['\u0634', '\u062c']), ('\ufd2e', &['\u0634', '\u062d']), ('\ufd2f',
- &['\u0634', '\u062e']), ('\ufd30', &['\u0634', '\u0645']), ('\ufd31', &['\u0633',
- '\u0647']), ('\ufd32', &['\u0634', '\u0647']), ('\ufd33', &['\u0637', '\u0645']), ('\ufd34',
- &['\u0633', '\u062c']), ('\ufd35', &['\u0633', '\u062d']), ('\ufd36', &['\u0633',
- '\u062e']), ('\ufd37', &['\u0634', '\u062c']), ('\ufd38', &['\u0634', '\u062d']), ('\ufd39',
- &['\u0634', '\u062e']), ('\ufd3a', &['\u0637', '\u0645']), ('\ufd3b', &['\u0638',
- '\u0645']), ('\ufd3c', &['\u0627', '\u064b']), ('\ufd3d', &['\u0627', '\u064b']), ('\ufd50',
- &['\u062a', '\u062c', '\u0645']), ('\ufd51', &['\u062a', '\u062d', '\u062c']), ('\ufd52',
- &['\u062a', '\u062d', '\u062c']), ('\ufd53', &['\u062a', '\u062d', '\u0645']), ('\ufd54',
- &['\u062a', '\u062e', '\u0645']), ('\ufd55', &['\u062a', '\u0645', '\u062c']), ('\ufd56',
- &['\u062a', '\u0645', '\u062d']), ('\ufd57', &['\u062a', '\u0645', '\u062e']), ('\ufd58',
- &['\u062c', '\u0645', '\u062d']), ('\ufd59', &['\u062c', '\u0645', '\u062d']), ('\ufd5a',
- &['\u062d', '\u0645', '\u064a']), ('\ufd5b', &['\u062d', '\u0645', '\u0649']), ('\ufd5c',
- &['\u0633', '\u062d', '\u062c']), ('\ufd5d', &['\u0633', '\u062c', '\u062d']), ('\ufd5e',
- &['\u0633', '\u062c', '\u0649']), ('\ufd5f', &['\u0633', '\u0645', '\u062d']), ('\ufd60',
- &['\u0633', '\u0645', '\u062d']), ('\ufd61', &['\u0633', '\u0645', '\u062c']), ('\ufd62',
- &['\u0633', '\u0645', '\u0645']), ('\ufd63', &['\u0633', '\u0645', '\u0645']), ('\ufd64',
- &['\u0635', '\u062d', '\u062d']), ('\ufd65', &['\u0635', '\u062d', '\u062d']), ('\ufd66',
- &['\u0635', '\u0645', '\u0645']), ('\ufd67', &['\u0634', '\u062d', '\u0645']), ('\ufd68',
- &['\u0634', '\u062d', '\u0645']), ('\ufd69', &['\u0634', '\u062c', '\u064a']), ('\ufd6a',
- &['\u0634', '\u0645', '\u062e']), ('\ufd6b', &['\u0634', '\u0645', '\u062e']), ('\ufd6c',
- &['\u0634', '\u0645', '\u0645']), ('\ufd6d', &['\u0634', '\u0645', '\u0645']), ('\ufd6e',
- &['\u0636', '\u062d', '\u0649']), ('\ufd6f', &['\u0636', '\u062e', '\u0645']), ('\ufd70',
- &['\u0636', '\u062e', '\u0645']), ('\ufd71', &['\u0637', '\u0645', '\u062d']), ('\ufd72',
- &['\u0637', '\u0645', '\u062d']), ('\ufd73', &['\u0637', '\u0645', '\u0645']), ('\ufd74',
- &['\u0637', '\u0645', '\u064a']), ('\ufd75', &['\u0639', '\u062c', '\u0645']), ('\ufd76',
- &['\u0639', '\u0645', '\u0645']), ('\ufd77', &['\u0639', '\u0645', '\u0645']), ('\ufd78',
- &['\u0639', '\u0645', '\u0649']), ('\ufd79', &['\u063a', '\u0645', '\u0645']), ('\ufd7a',
- &['\u063a', '\u0645', '\u064a']), ('\ufd7b', &['\u063a', '\u0645', '\u0649']), ('\ufd7c',
- &['\u0641', '\u062e', '\u0645']), ('\ufd7d', &['\u0641', '\u062e', '\u0645']), ('\ufd7e',
- &['\u0642', '\u0645', '\u062d']), ('\ufd7f', &['\u0642', '\u0645', '\u0645']), ('\ufd80',
- &['\u0644', '\u062d', '\u0645']), ('\ufd81', &['\u0644', '\u062d', '\u064a']), ('\ufd82',
- &['\u0644', '\u062d', '\u0649']), ('\ufd83', &['\u0644', '\u062c', '\u062c']), ('\ufd84',
- &['\u0644', '\u062c', '\u062c']), ('\ufd85', &['\u0644', '\u062e', '\u0645']), ('\ufd86',
- &['\u0644', '\u062e', '\u0645']), ('\ufd87', &['\u0644', '\u0645', '\u062d']), ('\ufd88',
- &['\u0644', '\u0645', '\u062d']), ('\ufd89', &['\u0645', '\u062d', '\u062c']), ('\ufd8a',
- &['\u0645', '\u062d', '\u0645']), ('\ufd8b', &['\u0645', '\u062d', '\u064a']), ('\ufd8c',
- &['\u0645', '\u062c', '\u062d']), ('\ufd8d', &['\u0645', '\u062c', '\u0645']), ('\ufd8e',
- &['\u0645', '\u062e', '\u062c']), ('\ufd8f', &['\u0645', '\u062e', '\u0645']), ('\ufd92',
- &['\u0645', '\u062c', '\u062e']), ('\ufd93', &['\u0647', '\u0645', '\u062c']), ('\ufd94',
- &['\u0647', '\u0645', '\u0645']), ('\ufd95', &['\u0646', '\u062d', '\u0645']), ('\ufd96',
- &['\u0646', '\u062d', '\u0649']), ('\ufd97', &['\u0646', '\u062c', '\u0645']), ('\ufd98',
- &['\u0646', '\u062c', '\u0645']), ('\ufd99', &['\u0646', '\u062c', '\u0649']), ('\ufd9a',
- &['\u0646', '\u0645', '\u064a']), ('\ufd9b', &['\u0646', '\u0645', '\u0649']), ('\ufd9c',
- &['\u064a', '\u0645', '\u0645']), ('\ufd9d', &['\u064a', '\u0645', '\u0645']), ('\ufd9e',
- &['\u0628', '\u062e', '\u064a']), ('\ufd9f', &['\u062a', '\u062c', '\u064a']), ('\ufda0',
- &['\u062a', '\u062c', '\u0649']), ('\ufda1', &['\u062a', '\u062e', '\u064a']), ('\ufda2',
- &['\u062a', '\u062e', '\u0649']), ('\ufda3', &['\u062a', '\u0645', '\u064a']), ('\ufda4',
- &['\u062a', '\u0645', '\u0649']), ('\ufda5', &['\u062c', '\u0645', '\u064a']), ('\ufda6',
- &['\u062c', '\u062d', '\u0649']), ('\ufda7', &['\u062c', '\u0645', '\u0649']), ('\ufda8',
- &['\u0633', '\u062e', '\u0649']), ('\ufda9', &['\u0635', '\u062d', '\u064a']), ('\ufdaa',
- &['\u0634', '\u062d', '\u064a']), ('\ufdab', &['\u0636', '\u062d', '\u064a']), ('\ufdac',
- &['\u0644', '\u062c', '\u064a']), ('\ufdad', &['\u0644', '\u0645', '\u064a']), ('\ufdae',
- &['\u064a', '\u062d', '\u064a']), ('\ufdaf', &['\u064a', '\u062c', '\u064a']), ('\ufdb0',
- &['\u064a', '\u0645', '\u064a']), ('\ufdb1', &['\u0645', '\u0645', '\u064a']), ('\ufdb2',
- &['\u0642', '\u0645', '\u064a']), ('\ufdb3', &['\u0646', '\u062d', '\u064a']), ('\ufdb4',
- &['\u0642', '\u0645', '\u062d']), ('\ufdb5', &['\u0644', '\u062d', '\u0645']), ('\ufdb6',
- &['\u0639', '\u0645', '\u064a']), ('\ufdb7', &['\u0643', '\u0645', '\u064a']), ('\ufdb8',
- &['\u0646', '\u062c', '\u062d']), ('\ufdb9', &['\u0645', '\u062e', '\u064a']), ('\ufdba',
- &['\u0644', '\u062c', '\u0645']), ('\ufdbb', &['\u0643', '\u0645', '\u0645']), ('\ufdbc',
- &['\u0644', '\u062c', '\u0645']), ('\ufdbd', &['\u0646', '\u062c', '\u062d']), ('\ufdbe',
- &['\u062c', '\u062d', '\u064a']), ('\ufdbf', &['\u062d', '\u062c', '\u064a']), ('\ufdc0',
- &['\u0645', '\u062c', '\u064a']), ('\ufdc1', &['\u0641', '\u0645', '\u064a']), ('\ufdc2',
- &['\u0628', '\u062d', '\u064a']), ('\ufdc3', &['\u0643', '\u0645', '\u0645']), ('\ufdc4',
- &['\u0639', '\u062c', '\u0645']), ('\ufdc5', &['\u0635', '\u0645', '\u0645']), ('\ufdc6',
- &['\u0633', '\u062e', '\u064a']), ('\ufdc7', &['\u0646', '\u062c', '\u064a']), ('\ufdf0',
- &['\u0635', '\u0644', '\u06d2']), ('\ufdf1', &['\u0642', '\u0644', '\u06d2']), ('\ufdf2',
- &['\u0627', '\u0644', '\u0644', '\u0647']), ('\ufdf3', &['\u0627', '\u0643', '\u0628',
- '\u0631']), ('\ufdf4', &['\u0645', '\u062d', '\u0645', '\u062f']), ('\ufdf5', &['\u0635',
- '\u0644', '\u0639', '\u0645']), ('\ufdf6', &['\u0631', '\u0633', '\u0648', '\u0644']),
- ('\ufdf7', &['\u0639', '\u0644', '\u064a', '\u0647']), ('\ufdf8', &['\u0648', '\u0633',
- '\u0644', '\u0645']), ('\ufdf9', &['\u0635', '\u0644', '\u0649']), ('\ufdfa', &['\u0635',
- '\u0644', '\u0649', '\x20', '\u0627', '\u0644', '\u0644', '\u0647', '\x20', '\u0639',
- '\u0644', '\u064a', '\u0647', '\x20', '\u0648', '\u0633', '\u0644', '\u0645']), ('\ufdfb',
- &['\u062c', '\u0644', '\x20', '\u062c', '\u0644', '\u0627', '\u0644', '\u0647']), ('\ufdfc',
- &['\u0631', '\u06cc', '\u0627', '\u0644']), ('\ufe10', &['\x2c']), ('\ufe11', &['\u3001']),
- ('\ufe12', &['\u3002']), ('\ufe13', &['\x3a']), ('\ufe14', &['\x3b']), ('\ufe15',
- &['\x21']), ('\ufe16', &['\x3f']), ('\ufe17', &['\u3016']), ('\ufe18', &['\u3017']),
- ('\ufe19', &['\u2026']), ('\ufe30', &['\u2025']), ('\ufe31', &['\u2014']), ('\ufe32',
- &['\u2013']), ('\ufe33', &['\x5f']), ('\ufe34', &['\x5f']), ('\ufe35', &['\x28']),
- ('\ufe36', &['\x29']), ('\ufe37', &['\x7b']), ('\ufe38', &['\x7d']), ('\ufe39',
- &['\u3014']), ('\ufe3a', &['\u3015']), ('\ufe3b', &['\u3010']), ('\ufe3c', &['\u3011']),
- ('\ufe3d', &['\u300a']), ('\ufe3e', &['\u300b']), ('\ufe3f', &['\u3008']), ('\ufe40',
- &['\u3009']), ('\ufe41', &['\u300c']), ('\ufe42', &['\u300d']), ('\ufe43', &['\u300e']),
- ('\ufe44', &['\u300f']), ('\ufe47', &['\x5b']), ('\ufe48', &['\x5d']), ('\ufe49',
- &['\u203e']), ('\ufe4a', &['\u203e']), ('\ufe4b', &['\u203e']), ('\ufe4c', &['\u203e']),
- ('\ufe4d', &['\x5f']), ('\ufe4e', &['\x5f']), ('\ufe4f', &['\x5f']), ('\ufe50', &['\x2c']),
- ('\ufe51', &['\u3001']), ('\ufe52', &['\x2e']), ('\ufe54', &['\x3b']), ('\ufe55',
- &['\x3a']), ('\ufe56', &['\x3f']), ('\ufe57', &['\x21']), ('\ufe58', &['\u2014']),
- ('\ufe59', &['\x28']), ('\ufe5a', &['\x29']), ('\ufe5b', &['\x7b']), ('\ufe5c', &['\x7d']),
- ('\ufe5d', &['\u3014']), ('\ufe5e', &['\u3015']), ('\ufe5f', &['\x23']), ('\ufe60',
- &['\x26']), ('\ufe61', &['\x2a']), ('\ufe62', &['\x2b']), ('\ufe63', &['\x2d']), ('\ufe64',
- &['\x3c']), ('\ufe65', &['\x3e']), ('\ufe66', &['\x3d']), ('\ufe68', &['\x5c']), ('\ufe69',
- &['\x24']), ('\ufe6a', &['\x25']), ('\ufe6b', &['\x40']), ('\ufe70', &['\x20', '\u064b']),
- ('\ufe71', &['\u0640', '\u064b']), ('\ufe72', &['\x20', '\u064c']), ('\ufe74', &['\x20',
- '\u064d']), ('\ufe76', &['\x20', '\u064e']), ('\ufe77', &['\u0640', '\u064e']), ('\ufe78',
- &['\x20', '\u064f']), ('\ufe79', &['\u0640', '\u064f']), ('\ufe7a', &['\x20', '\u0650']),
- ('\ufe7b', &['\u0640', '\u0650']), ('\ufe7c', &['\x20', '\u0651']), ('\ufe7d', &['\u0640',
- '\u0651']), ('\ufe7e', &['\x20', '\u0652']), ('\ufe7f', &['\u0640', '\u0652']), ('\ufe80',
- &['\u0621']), ('\ufe81', &['\u0622']), ('\ufe82', &['\u0622']), ('\ufe83', &['\u0623']),
- ('\ufe84', &['\u0623']), ('\ufe85', &['\u0624']), ('\ufe86', &['\u0624']), ('\ufe87',
- &['\u0625']), ('\ufe88', &['\u0625']), ('\ufe89', &['\u0626']), ('\ufe8a', &['\u0626']),
- ('\ufe8b', &['\u0626']), ('\ufe8c', &['\u0626']), ('\ufe8d', &['\u0627']), ('\ufe8e',
- &['\u0627']), ('\ufe8f', &['\u0628']), ('\ufe90', &['\u0628']), ('\ufe91', &['\u0628']),
- ('\ufe92', &['\u0628']), ('\ufe93', &['\u0629']), ('\ufe94', &['\u0629']), ('\ufe95',
- &['\u062a']), ('\ufe96', &['\u062a']), ('\ufe97', &['\u062a']), ('\ufe98', &['\u062a']),
- ('\ufe99', &['\u062b']), ('\ufe9a', &['\u062b']), ('\ufe9b', &['\u062b']), ('\ufe9c',
- &['\u062b']), ('\ufe9d', &['\u062c']), ('\ufe9e', &['\u062c']), ('\ufe9f', &['\u062c']),
- ('\ufea0', &['\u062c']), ('\ufea1', &['\u062d']), ('\ufea2', &['\u062d']), ('\ufea3',
- &['\u062d']), ('\ufea4', &['\u062d']), ('\ufea5', &['\u062e']), ('\ufea6', &['\u062e']),
- ('\ufea7', &['\u062e']), ('\ufea8', &['\u062e']), ('\ufea9', &['\u062f']), ('\ufeaa',
- &['\u062f']), ('\ufeab', &['\u0630']), ('\ufeac', &['\u0630']), ('\ufead', &['\u0631']),
- ('\ufeae', &['\u0631']), ('\ufeaf', &['\u0632']), ('\ufeb0', &['\u0632']), ('\ufeb1',
- &['\u0633']), ('\ufeb2', &['\u0633']), ('\ufeb3', &['\u0633']), ('\ufeb4', &['\u0633']),
- ('\ufeb5', &['\u0634']), ('\ufeb6', &['\u0634']), ('\ufeb7', &['\u0634']), ('\ufeb8',
- &['\u0634']), ('\ufeb9', &['\u0635']), ('\ufeba', &['\u0635']), ('\ufebb', &['\u0635']),
- ('\ufebc', &['\u0635']), ('\ufebd', &['\u0636']), ('\ufebe', &['\u0636']), ('\ufebf',
- &['\u0636']), ('\ufec0', &['\u0636']), ('\ufec1', &['\u0637']), ('\ufec2', &['\u0637']),
- ('\ufec3', &['\u0637']), ('\ufec4', &['\u0637']), ('\ufec5', &['\u0638']), ('\ufec6',
- &['\u0638']), ('\ufec7', &['\u0638']), ('\ufec8', &['\u0638']), ('\ufec9', &['\u0639']),
- ('\ufeca', &['\u0639']), ('\ufecb', &['\u0639']), ('\ufecc', &['\u0639']), ('\ufecd',
- &['\u063a']), ('\ufece', &['\u063a']), ('\ufecf', &['\u063a']), ('\ufed0', &['\u063a']),
- ('\ufed1', &['\u0641']), ('\ufed2', &['\u0641']), ('\ufed3', &['\u0641']), ('\ufed4',
- &['\u0641']), ('\ufed5', &['\u0642']), ('\ufed6', &['\u0642']), ('\ufed7', &['\u0642']),
- ('\ufed8', &['\u0642']), ('\ufed9', &['\u0643']), ('\ufeda', &['\u0643']), ('\ufedb',
- &['\u0643']), ('\ufedc', &['\u0643']), ('\ufedd', &['\u0644']), ('\ufede', &['\u0644']),
- ('\ufedf', &['\u0644']), ('\ufee0', &['\u0644']), ('\ufee1', &['\u0645']), ('\ufee2',
- &['\u0645']), ('\ufee3', &['\u0645']), ('\ufee4', &['\u0645']), ('\ufee5', &['\u0646']),
- ('\ufee6', &['\u0646']), ('\ufee7', &['\u0646']), ('\ufee8', &['\u0646']), ('\ufee9',
- &['\u0647']), ('\ufeea', &['\u0647']), ('\ufeeb', &['\u0647']), ('\ufeec', &['\u0647']),
- ('\ufeed', &['\u0648']), ('\ufeee', &['\u0648']), ('\ufeef', &['\u0649']), ('\ufef0',
- &['\u0649']), ('\ufef1', &['\u064a']), ('\ufef2', &['\u064a']), ('\ufef3', &['\u064a']),
- ('\ufef4', &['\u064a']), ('\ufef5', &['\u0644', '\u0622']), ('\ufef6', &['\u0644',
- '\u0622']), ('\ufef7', &['\u0644', '\u0623']), ('\ufef8', &['\u0644', '\u0623']), ('\ufef9',
- &['\u0644', '\u0625']), ('\ufefa', &['\u0644', '\u0625']), ('\ufefb', &['\u0644',
- '\u0627']), ('\ufefc', &['\u0644', '\u0627']), ('\uff01', &['\x21']), ('\uff02', &['\x22']),
- ('\uff03', &['\x23']), ('\uff04', &['\x24']), ('\uff05', &['\x25']), ('\uff06', &['\x26']),
- ('\uff07', &['\x27']), ('\uff08', &['\x28']), ('\uff09', &['\x29']), ('\uff0a', &['\x2a']),
- ('\uff0b', &['\x2b']), ('\uff0c', &['\x2c']), ('\uff0d', &['\x2d']), ('\uff0e', &['\x2e']),
- ('\uff0f', &['\x2f']), ('\uff10', &['\x30']), ('\uff11', &['\x31']), ('\uff12', &['\x32']),
- ('\uff13', &['\x33']), ('\uff14', &['\x34']), ('\uff15', &['\x35']), ('\uff16', &['\x36']),
- ('\uff17', &['\x37']), ('\uff18', &['\x38']), ('\uff19', &['\x39']), ('\uff1a', &['\x3a']),
- ('\uff1b', &['\x3b']), ('\uff1c', &['\x3c']), ('\uff1d', &['\x3d']), ('\uff1e', &['\x3e']),
- ('\uff1f', &['\x3f']), ('\uff20', &['\x40']), ('\uff21', &['\x41']), ('\uff22', &['\x42']),
- ('\uff23', &['\x43']), ('\uff24', &['\x44']), ('\uff25', &['\x45']), ('\uff26', &['\x46']),
- ('\uff27', &['\x47']), ('\uff28', &['\x48']), ('\uff29', &['\x49']), ('\uff2a', &['\x4a']),
- ('\uff2b', &['\x4b']), ('\uff2c', &['\x4c']), ('\uff2d', &['\x4d']), ('\uff2e', &['\x4e']),
- ('\uff2f', &['\x4f']), ('\uff30', &['\x50']), ('\uff31', &['\x51']), ('\uff32', &['\x52']),
- ('\uff33', &['\x53']), ('\uff34', &['\x54']), ('\uff35', &['\x55']), ('\uff36', &['\x56']),
- ('\uff37', &['\x57']), ('\uff38', &['\x58']), ('\uff39', &['\x59']), ('\uff3a', &['\x5a']),
- ('\uff3b', &['\x5b']), ('\uff3c', &['\x5c']), ('\uff3d', &['\x5d']), ('\uff3e', &['\x5e']),
- ('\uff3f', &['\x5f']), ('\uff40', &['\x60']), ('\uff41', &['\x61']), ('\uff42', &['\x62']),
- ('\uff43', &['\x63']), ('\uff44', &['\x64']), ('\uff45', &['\x65']), ('\uff46', &['\x66']),
- ('\uff47', &['\x67']), ('\uff48', &['\x68']), ('\uff49', &['\x69']), ('\uff4a', &['\x6a']),
- ('\uff4b', &['\x6b']), ('\uff4c', &['\x6c']), ('\uff4d', &['\x6d']), ('\uff4e', &['\x6e']),
- ('\uff4f', &['\x6f']), ('\uff50', &['\x70']), ('\uff51', &['\x71']), ('\uff52', &['\x72']),
- ('\uff53', &['\x73']), ('\uff54', &['\x74']), ('\uff55', &['\x75']), ('\uff56', &['\x76']),
- ('\uff57', &['\x77']), ('\uff58', &['\x78']), ('\uff59', &['\x79']), ('\uff5a', &['\x7a']),
- ('\uff5b', &['\x7b']), ('\uff5c', &['\x7c']), ('\uff5d', &['\x7d']), ('\uff5e', &['\x7e']),
- ('\uff5f', &['\u2985']), ('\uff60', &['\u2986']), ('\uff61', &['\u3002']), ('\uff62',
- &['\u300c']), ('\uff63', &['\u300d']), ('\uff64', &['\u3001']), ('\uff65', &['\u30fb']),
- ('\uff66', &['\u30f2']), ('\uff67', &['\u30a1']), ('\uff68', &['\u30a3']), ('\uff69',
- &['\u30a5']), ('\uff6a', &['\u30a7']), ('\uff6b', &['\u30a9']), ('\uff6c', &['\u30e3']),
- ('\uff6d', &['\u30e5']), ('\uff6e', &['\u30e7']), ('\uff6f', &['\u30c3']), ('\uff70',
- &['\u30fc']), ('\uff71', &['\u30a2']), ('\uff72', &['\u30a4']), ('\uff73', &['\u30a6']),
- ('\uff74', &['\u30a8']), ('\uff75', &['\u30aa']), ('\uff76', &['\u30ab']), ('\uff77',
- &['\u30ad']), ('\uff78', &['\u30af']), ('\uff79', &['\u30b1']), ('\uff7a', &['\u30b3']),
- ('\uff7b', &['\u30b5']), ('\uff7c', &['\u30b7']), ('\uff7d', &['\u30b9']), ('\uff7e',
- &['\u30bb']), ('\uff7f', &['\u30bd']), ('\uff80', &['\u30bf']), ('\uff81', &['\u30c1']),
- ('\uff82', &['\u30c4']), ('\uff83', &['\u30c6']), ('\uff84', &['\u30c8']), ('\uff85',
- &['\u30ca']), ('\uff86', &['\u30cb']), ('\uff87', &['\u30cc']), ('\uff88', &['\u30cd']),
- ('\uff89', &['\u30ce']), ('\uff8a', &['\u30cf']), ('\uff8b', &['\u30d2']), ('\uff8c',
- &['\u30d5']), ('\uff8d', &['\u30d8']), ('\uff8e', &['\u30db']), ('\uff8f', &['\u30de']),
- ('\uff90', &['\u30df']), ('\uff91', &['\u30e0']), ('\uff92', &['\u30e1']), ('\uff93',
- &['\u30e2']), ('\uff94', &['\u30e4']), ('\uff95', &['\u30e6']), ('\uff96', &['\u30e8']),
- ('\uff97', &['\u30e9']), ('\uff98', &['\u30ea']), ('\uff99', &['\u30eb']), ('\uff9a',
- &['\u30ec']), ('\uff9b', &['\u30ed']), ('\uff9c', &['\u30ef']), ('\uff9d', &['\u30f3']),
- ('\uff9e', &['\u3099']), ('\uff9f', &['\u309a']), ('\uffa0', &['\u3164']), ('\uffa1',
- &['\u3131']), ('\uffa2', &['\u3132']), ('\uffa3', &['\u3133']), ('\uffa4', &['\u3134']),
- ('\uffa5', &['\u3135']), ('\uffa6', &['\u3136']), ('\uffa7', &['\u3137']), ('\uffa8',
- &['\u3138']), ('\uffa9', &['\u3139']), ('\uffaa', &['\u313a']), ('\uffab', &['\u313b']),
- ('\uffac', &['\u313c']), ('\uffad', &['\u313d']), ('\uffae', &['\u313e']), ('\uffaf',
- &['\u313f']), ('\uffb0', &['\u3140']), ('\uffb1', &['\u3141']), ('\uffb2', &['\u3142']),
- ('\uffb3', &['\u3143']), ('\uffb4', &['\u3144']), ('\uffb5', &['\u3145']), ('\uffb6',
- &['\u3146']), ('\uffb7', &['\u3147']), ('\uffb8', &['\u3148']), ('\uffb9', &['\u3149']),
- ('\uffba', &['\u314a']), ('\uffbb', &['\u314b']), ('\uffbc', &['\u314c']), ('\uffbd',
- &['\u314d']), ('\uffbe', &['\u314e']), ('\uffc2', &['\u314f']), ('\uffc3', &['\u3150']),
- ('\uffc4', &['\u3151']), ('\uffc5', &['\u3152']), ('\uffc6', &['\u3153']), ('\uffc7',
- &['\u3154']), ('\uffca', &['\u3155']), ('\uffcb', &['\u3156']), ('\uffcc', &['\u3157']),
- ('\uffcd', &['\u3158']), ('\uffce', &['\u3159']), ('\uffcf', &['\u315a']), ('\uffd2',
- &['\u315b']), ('\uffd3', &['\u315c']), ('\uffd4', &['\u315d']), ('\uffd5', &['\u315e']),
- ('\uffd6', &['\u315f']), ('\uffd7', &['\u3160']), ('\uffda', &['\u3161']), ('\uffdb',
- &['\u3162']), ('\uffdc', &['\u3163']), ('\uffe0', &['\xa2']), ('\uffe1', &['\xa3']),
- ('\uffe2', &['\xac']), ('\uffe3', &['\xaf']), ('\uffe4', &['\xa6']), ('\uffe5', &['\xa5']),
- ('\uffe6', &['\u20a9']), ('\uffe8', &['\u2502']), ('\uffe9', &['\u2190']), ('\uffea',
- &['\u2191']), ('\uffeb', &['\u2192']), ('\uffec', &['\u2193']), ('\uffed', &['\u25a0']),
- ('\uffee', &['\u25cb']), ('\U0001d400', &['\x41']), ('\U0001d401', &['\x42']),
- ('\U0001d402', &['\x43']), ('\U0001d403', &['\x44']), ('\U0001d404', &['\x45']),
- ('\U0001d405', &['\x46']), ('\U0001d406', &['\x47']), ('\U0001d407', &['\x48']),
- ('\U0001d408', &['\x49']), ('\U0001d409', &['\x4a']), ('\U0001d40a', &['\x4b']),
- ('\U0001d40b', &['\x4c']), ('\U0001d40c', &['\x4d']), ('\U0001d40d', &['\x4e']),
- ('\U0001d40e', &['\x4f']), ('\U0001d40f', &['\x50']), ('\U0001d410', &['\x51']),
- ('\U0001d411', &['\x52']), ('\U0001d412', &['\x53']), ('\U0001d413', &['\x54']),
- ('\U0001d414', &['\x55']), ('\U0001d415', &['\x56']), ('\U0001d416', &['\x57']),
- ('\U0001d417', &['\x58']), ('\U0001d418', &['\x59']), ('\U0001d419', &['\x5a']),
- ('\U0001d41a', &['\x61']), ('\U0001d41b', &['\x62']), ('\U0001d41c', &['\x63']),
- ('\U0001d41d', &['\x64']), ('\U0001d41e', &['\x65']), ('\U0001d41f', &['\x66']),
- ('\U0001d420', &['\x67']), ('\U0001d421', &['\x68']), ('\U0001d422', &['\x69']),
- ('\U0001d423', &['\x6a']), ('\U0001d424', &['\x6b']), ('\U0001d425', &['\x6c']),
- ('\U0001d426', &['\x6d']), ('\U0001d427', &['\x6e']), ('\U0001d428', &['\x6f']),
- ('\U0001d429', &['\x70']), ('\U0001d42a', &['\x71']), ('\U0001d42b', &['\x72']),
- ('\U0001d42c', &['\x73']), ('\U0001d42d', &['\x74']), ('\U0001d42e', &['\x75']),
- ('\U0001d42f', &['\x76']), ('\U0001d430', &['\x77']), ('\U0001d431', &['\x78']),
- ('\U0001d432', &['\x79']), ('\U0001d433', &['\x7a']), ('\U0001d434', &['\x41']),
- ('\U0001d435', &['\x42']), ('\U0001d436', &['\x43']), ('\U0001d437', &['\x44']),
- ('\U0001d438', &['\x45']), ('\U0001d439', &['\x46']), ('\U0001d43a', &['\x47']),
- ('\U0001d43b', &['\x48']), ('\U0001d43c', &['\x49']), ('\U0001d43d', &['\x4a']),
- ('\U0001d43e', &['\x4b']), ('\U0001d43f', &['\x4c']), ('\U0001d440', &['\x4d']),
- ('\U0001d441', &['\x4e']), ('\U0001d442', &['\x4f']), ('\U0001d443', &['\x50']),
- ('\U0001d444', &['\x51']), ('\U0001d445', &['\x52']), ('\U0001d446', &['\x53']),
- ('\U0001d447', &['\x54']), ('\U0001d448', &['\x55']), ('\U0001d449', &['\x56']),
- ('\U0001d44a', &['\x57']), ('\U0001d44b', &['\x58']), ('\U0001d44c', &['\x59']),
- ('\U0001d44d', &['\x5a']), ('\U0001d44e', &['\x61']), ('\U0001d44f', &['\x62']),
- ('\U0001d450', &['\x63']), ('\U0001d451', &['\x64']), ('\U0001d452', &['\x65']),
- ('\U0001d453', &['\x66']), ('\U0001d454', &['\x67']), ('\U0001d456', &['\x69']),
- ('\U0001d457', &['\x6a']), ('\U0001d458', &['\x6b']), ('\U0001d459', &['\x6c']),
- ('\U0001d45a', &['\x6d']), ('\U0001d45b', &['\x6e']), ('\U0001d45c', &['\x6f']),
- ('\U0001d45d', &['\x70']), ('\U0001d45e', &['\x71']), ('\U0001d45f', &['\x72']),
- ('\U0001d460', &['\x73']), ('\U0001d461', &['\x74']), ('\U0001d462', &['\x75']),
- ('\U0001d463', &['\x76']), ('\U0001d464', &['\x77']), ('\U0001d465', &['\x78']),
- ('\U0001d466', &['\x79']), ('\U0001d467', &['\x7a']), ('\U0001d468', &['\x41']),
- ('\U0001d469', &['\x42']), ('\U0001d46a', &['\x43']), ('\U0001d46b', &['\x44']),
- ('\U0001d46c', &['\x45']), ('\U0001d46d', &['\x46']), ('\U0001d46e', &['\x47']),
- ('\U0001d46f', &['\x48']), ('\U0001d470', &['\x49']), ('\U0001d471', &['\x4a']),
- ('\U0001d472', &['\x4b']), ('\U0001d473', &['\x4c']), ('\U0001d474', &['\x4d']),
- ('\U0001d475', &['\x4e']), ('\U0001d476', &['\x4f']), ('\U0001d477', &['\x50']),
- ('\U0001d478', &['\x51']), ('\U0001d479', &['\x52']), ('\U0001d47a', &['\x53']),
- ('\U0001d47b', &['\x54']), ('\U0001d47c', &['\x55']), ('\U0001d47d', &['\x56']),
- ('\U0001d47e', &['\x57']), ('\U0001d47f', &['\x58']), ('\U0001d480', &['\x59']),
- ('\U0001d481', &['\x5a']), ('\U0001d482', &['\x61']), ('\U0001d483', &['\x62']),
- ('\U0001d484', &['\x63']), ('\U0001d485', &['\x64']), ('\U0001d486', &['\x65']),
- ('\U0001d487', &['\x66']), ('\U0001d488', &['\x67']), ('\U0001d489', &['\x68']),
- ('\U0001d48a', &['\x69']), ('\U0001d48b', &['\x6a']), ('\U0001d48c', &['\x6b']),
- ('\U0001d48d', &['\x6c']), ('\U0001d48e', &['\x6d']), ('\U0001d48f', &['\x6e']),
- ('\U0001d490', &['\x6f']), ('\U0001d491', &['\x70']), ('\U0001d492', &['\x71']),
- ('\U0001d493', &['\x72']), ('\U0001d494', &['\x73']), ('\U0001d495', &['\x74']),
- ('\U0001d496', &['\x75']), ('\U0001d497', &['\x76']), ('\U0001d498', &['\x77']),
- ('\U0001d499', &['\x78']), ('\U0001d49a', &['\x79']), ('\U0001d49b', &['\x7a']),
- ('\U0001d49c', &['\x41']), ('\U0001d49e', &['\x43']), ('\U0001d49f', &['\x44']),
- ('\U0001d4a2', &['\x47']), ('\U0001d4a5', &['\x4a']), ('\U0001d4a6', &['\x4b']),
- ('\U0001d4a9', &['\x4e']), ('\U0001d4aa', &['\x4f']), ('\U0001d4ab', &['\x50']),
- ('\U0001d4ac', &['\x51']), ('\U0001d4ae', &['\x53']), ('\U0001d4af', &['\x54']),
- ('\U0001d4b0', &['\x55']), ('\U0001d4b1', &['\x56']), ('\U0001d4b2', &['\x57']),
- ('\U0001d4b3', &['\x58']), ('\U0001d4b4', &['\x59']), ('\U0001d4b5', &['\x5a']),
- ('\U0001d4b6', &['\x61']), ('\U0001d4b7', &['\x62']), ('\U0001d4b8', &['\x63']),
- ('\U0001d4b9', &['\x64']), ('\U0001d4bb', &['\x66']), ('\U0001d4bd', &['\x68']),
- ('\U0001d4be', &['\x69']), ('\U0001d4bf', &['\x6a']), ('\U0001d4c0', &['\x6b']),
- ('\U0001d4c1', &['\x6c']), ('\U0001d4c2', &['\x6d']), ('\U0001d4c3', &['\x6e']),
- ('\U0001d4c5', &['\x70']), ('\U0001d4c6', &['\x71']), ('\U0001d4c7', &['\x72']),
- ('\U0001d4c8', &['\x73']), ('\U0001d4c9', &['\x74']), ('\U0001d4ca', &['\x75']),
- ('\U0001d4cb', &['\x76']), ('\U0001d4cc', &['\x77']), ('\U0001d4cd', &['\x78']),
- ('\U0001d4ce', &['\x79']), ('\U0001d4cf', &['\x7a']), ('\U0001d4d0', &['\x41']),
- ('\U0001d4d1', &['\x42']), ('\U0001d4d2', &['\x43']), ('\U0001d4d3', &['\x44']),
- ('\U0001d4d4', &['\x45']), ('\U0001d4d5', &['\x46']), ('\U0001d4d6', &['\x47']),
- ('\U0001d4d7', &['\x48']), ('\U0001d4d8', &['\x49']), ('\U0001d4d9', &['\x4a']),
- ('\U0001d4da', &['\x4b']), ('\U0001d4db', &['\x4c']), ('\U0001d4dc', &['\x4d']),
- ('\U0001d4dd', &['\x4e']), ('\U0001d4de', &['\x4f']), ('\U0001d4df', &['\x50']),
- ('\U0001d4e0', &['\x51']), ('\U0001d4e1', &['\x52']), ('\U0001d4e2', &['\x53']),
- ('\U0001d4e3', &['\x54']), ('\U0001d4e4', &['\x55']), ('\U0001d4e5', &['\x56']),
- ('\U0001d4e6', &['\x57']), ('\U0001d4e7', &['\x58']), ('\U0001d4e8', &['\x59']),
- ('\U0001d4e9', &['\x5a']), ('\U0001d4ea', &['\x61']), ('\U0001d4eb', &['\x62']),
- ('\U0001d4ec', &['\x63']), ('\U0001d4ed', &['\x64']), ('\U0001d4ee', &['\x65']),
- ('\U0001d4ef', &['\x66']), ('\U0001d4f0', &['\x67']), ('\U0001d4f1', &['\x68']),
- ('\U0001d4f2', &['\x69']), ('\U0001d4f3', &['\x6a']), ('\U0001d4f4', &['\x6b']),
- ('\U0001d4f5', &['\x6c']), ('\U0001d4f6', &['\x6d']), ('\U0001d4f7', &['\x6e']),
- ('\U0001d4f8', &['\x6f']), ('\U0001d4f9', &['\x70']), ('\U0001d4fa', &['\x71']),
- ('\U0001d4fb', &['\x72']), ('\U0001d4fc', &['\x73']), ('\U0001d4fd', &['\x74']),
- ('\U0001d4fe', &['\x75']), ('\U0001d4ff', &['\x76']), ('\U0001d500', &['\x77']),
- ('\U0001d501', &['\x78']), ('\U0001d502', &['\x79']), ('\U0001d503', &['\x7a']),
- ('\U0001d504', &['\x41']), ('\U0001d505', &['\x42']), ('\U0001d507', &['\x44']),
- ('\U0001d508', &['\x45']), ('\U0001d509', &['\x46']), ('\U0001d50a', &['\x47']),
- ('\U0001d50d', &['\x4a']), ('\U0001d50e', &['\x4b']), ('\U0001d50f', &['\x4c']),
- ('\U0001d510', &['\x4d']), ('\U0001d511', &['\x4e']), ('\U0001d512', &['\x4f']),
- ('\U0001d513', &['\x50']), ('\U0001d514', &['\x51']), ('\U0001d516', &['\x53']),
- ('\U0001d517', &['\x54']), ('\U0001d518', &['\x55']), ('\U0001d519', &['\x56']),
- ('\U0001d51a', &['\x57']), ('\U0001d51b', &['\x58']), ('\U0001d51c', &['\x59']),
- ('\U0001d51e', &['\x61']), ('\U0001d51f', &['\x62']), ('\U0001d520', &['\x63']),
- ('\U0001d521', &['\x64']), ('\U0001d522', &['\x65']), ('\U0001d523', &['\x66']),
- ('\U0001d524', &['\x67']), ('\U0001d525', &['\x68']), ('\U0001d526', &['\x69']),
- ('\U0001d527', &['\x6a']), ('\U0001d528', &['\x6b']), ('\U0001d529', &['\x6c']),
- ('\U0001d52a', &['\x6d']), ('\U0001d52b', &['\x6e']), ('\U0001d52c', &['\x6f']),
- ('\U0001d52d', &['\x70']), ('\U0001d52e', &['\x71']), ('\U0001d52f', &['\x72']),
- ('\U0001d530', &['\x73']), ('\U0001d531', &['\x74']), ('\U0001d532', &['\x75']),
- ('\U0001d533', &['\x76']), ('\U0001d534', &['\x77']), ('\U0001d535', &['\x78']),
- ('\U0001d536', &['\x79']), ('\U0001d537', &['\x7a']), ('\U0001d538', &['\x41']),
- ('\U0001d539', &['\x42']), ('\U0001d53b', &['\x44']), ('\U0001d53c', &['\x45']),
- ('\U0001d53d', &['\x46']), ('\U0001d53e', &['\x47']), ('\U0001d540', &['\x49']),
- ('\U0001d541', &['\x4a']), ('\U0001d542', &['\x4b']), ('\U0001d543', &['\x4c']),
- ('\U0001d544', &['\x4d']), ('\U0001d546', &['\x4f']), ('\U0001d54a', &['\x53']),
- ('\U0001d54b', &['\x54']), ('\U0001d54c', &['\x55']), ('\U0001d54d', &['\x56']),
- ('\U0001d54e', &['\x57']), ('\U0001d54f', &['\x58']), ('\U0001d550', &['\x59']),
- ('\U0001d552', &['\x61']), ('\U0001d553', &['\x62']), ('\U0001d554', &['\x63']),
- ('\U0001d555', &['\x64']), ('\U0001d556', &['\x65']), ('\U0001d557', &['\x66']),
- ('\U0001d558', &['\x67']), ('\U0001d559', &['\x68']), ('\U0001d55a', &['\x69']),
- ('\U0001d55b', &['\x6a']), ('\U0001d55c', &['\x6b']), ('\U0001d55d', &['\x6c']),
- ('\U0001d55e', &['\x6d']), ('\U0001d55f', &['\x6e']), ('\U0001d560', &['\x6f']),
- ('\U0001d561', &['\x70']), ('\U0001d562', &['\x71']), ('\U0001d563', &['\x72']),
- ('\U0001d564', &['\x73']), ('\U0001d565', &['\x74']), ('\U0001d566', &['\x75']),
- ('\U0001d567', &['\x76']), ('\U0001d568', &['\x77']), ('\U0001d569', &['\x78']),
- ('\U0001d56a', &['\x79']), ('\U0001d56b', &['\x7a']), ('\U0001d56c', &['\x41']),
- ('\U0001d56d', &['\x42']), ('\U0001d56e', &['\x43']), ('\U0001d56f', &['\x44']),
- ('\U0001d570', &['\x45']), ('\U0001d571', &['\x46']), ('\U0001d572', &['\x47']),
- ('\U0001d573', &['\x48']), ('\U0001d574', &['\x49']), ('\U0001d575', &['\x4a']),
- ('\U0001d576', &['\x4b']), ('\U0001d577', &['\x4c']), ('\U0001d578', &['\x4d']),
- ('\U0001d579', &['\x4e']), ('\U0001d57a', &['\x4f']), ('\U0001d57b', &['\x50']),
- ('\U0001d57c', &['\x51']), ('\U0001d57d', &['\x52']), ('\U0001d57e', &['\x53']),
- ('\U0001d57f', &['\x54']), ('\U0001d580', &['\x55']), ('\U0001d581', &['\x56']),
- ('\U0001d582', &['\x57']), ('\U0001d583', &['\x58']), ('\U0001d584', &['\x59']),
- ('\U0001d585', &['\x5a']), ('\U0001d586', &['\x61']), ('\U0001d587', &['\x62']),
- ('\U0001d588', &['\x63']), ('\U0001d589', &['\x64']), ('\U0001d58a', &['\x65']),
- ('\U0001d58b', &['\x66']), ('\U0001d58c', &['\x67']), ('\U0001d58d', &['\x68']),
- ('\U0001d58e', &['\x69']), ('\U0001d58f', &['\x6a']), ('\U0001d590', &['\x6b']),
- ('\U0001d591', &['\x6c']), ('\U0001d592', &['\x6d']), ('\U0001d593', &['\x6e']),
- ('\U0001d594', &['\x6f']), ('\U0001d595', &['\x70']), ('\U0001d596', &['\x71']),
- ('\U0001d597', &['\x72']), ('\U0001d598', &['\x73']), ('\U0001d599', &['\x74']),
- ('\U0001d59a', &['\x75']), ('\U0001d59b', &['\x76']), ('\U0001d59c', &['\x77']),
- ('\U0001d59d', &['\x78']), ('\U0001d59e', &['\x79']), ('\U0001d59f', &['\x7a']),
- ('\U0001d5a0', &['\x41']), ('\U0001d5a1', &['\x42']), ('\U0001d5a2', &['\x43']),
- ('\U0001d5a3', &['\x44']), ('\U0001d5a4', &['\x45']), ('\U0001d5a5', &['\x46']),
- ('\U0001d5a6', &['\x47']), ('\U0001d5a7', &['\x48']), ('\U0001d5a8', &['\x49']),
- ('\U0001d5a9', &['\x4a']), ('\U0001d5aa', &['\x4b']), ('\U0001d5ab', &['\x4c']),
- ('\U0001d5ac', &['\x4d']), ('\U0001d5ad', &['\x4e']), ('\U0001d5ae', &['\x4f']),
- ('\U0001d5af', &['\x50']), ('\U0001d5b0', &['\x51']), ('\U0001d5b1', &['\x52']),
- ('\U0001d5b2', &['\x53']), ('\U0001d5b3', &['\x54']), ('\U0001d5b4', &['\x55']),
- ('\U0001d5b5', &['\x56']), ('\U0001d5b6', &['\x57']), ('\U0001d5b7', &['\x58']),
- ('\U0001d5b8', &['\x59']), ('\U0001d5b9', &['\x5a']), ('\U0001d5ba', &['\x61']),
- ('\U0001d5bb', &['\x62']), ('\U0001d5bc', &['\x63']), ('\U0001d5bd', &['\x64']),
- ('\U0001d5be', &['\x65']), ('\U0001d5bf', &['\x66']), ('\U0001d5c0', &['\x67']),
- ('\U0001d5c1', &['\x68']), ('\U0001d5c2', &['\x69']), ('\U0001d5c3', &['\x6a']),
- ('\U0001d5c4', &['\x6b']), ('\U0001d5c5', &['\x6c']), ('\U0001d5c6', &['\x6d']),
- ('\U0001d5c7', &['\x6e']), ('\U0001d5c8', &['\x6f']), ('\U0001d5c9', &['\x70']),
- ('\U0001d5ca', &['\x71']), ('\U0001d5cb', &['\x72']), ('\U0001d5cc', &['\x73']),
- ('\U0001d5cd', &['\x74']), ('\U0001d5ce', &['\x75']), ('\U0001d5cf', &['\x76']),
- ('\U0001d5d0', &['\x77']), ('\U0001d5d1', &['\x78']), ('\U0001d5d2', &['\x79']),
- ('\U0001d5d3', &['\x7a']), ('\U0001d5d4', &['\x41']), ('\U0001d5d5', &['\x42']),
- ('\U0001d5d6', &['\x43']), ('\U0001d5d7', &['\x44']), ('\U0001d5d8', &['\x45']),
- ('\U0001d5d9', &['\x46']), ('\U0001d5da', &['\x47']), ('\U0001d5db', &['\x48']),
- ('\U0001d5dc', &['\x49']), ('\U0001d5dd', &['\x4a']), ('\U0001d5de', &['\x4b']),
- ('\U0001d5df', &['\x4c']), ('\U0001d5e0', &['\x4d']), ('\U0001d5e1', &['\x4e']),
- ('\U0001d5e2', &['\x4f']), ('\U0001d5e3', &['\x50']), ('\U0001d5e4', &['\x51']),
- ('\U0001d5e5', &['\x52']), ('\U0001d5e6', &['\x53']), ('\U0001d5e7', &['\x54']),
- ('\U0001d5e8', &['\x55']), ('\U0001d5e9', &['\x56']), ('\U0001d5ea', &['\x57']),
- ('\U0001d5eb', &['\x58']), ('\U0001d5ec', &['\x59']), ('\U0001d5ed', &['\x5a']),
- ('\U0001d5ee', &['\x61']), ('\U0001d5ef', &['\x62']), ('\U0001d5f0', &['\x63']),
- ('\U0001d5f1', &['\x64']), ('\U0001d5f2', &['\x65']), ('\U0001d5f3', &['\x66']),
- ('\U0001d5f4', &['\x67']), ('\U0001d5f5', &['\x68']), ('\U0001d5f6', &['\x69']),
- ('\U0001d5f7', &['\x6a']), ('\U0001d5f8', &['\x6b']), ('\U0001d5f9', &['\x6c']),
- ('\U0001d5fa', &['\x6d']), ('\U0001d5fb', &['\x6e']), ('\U0001d5fc', &['\x6f']),
- ('\U0001d5fd', &['\x70']), ('\U0001d5fe', &['\x71']), ('\U0001d5ff', &['\x72']),
- ('\U0001d600', &['\x73']), ('\U0001d601', &['\x74']), ('\U0001d602', &['\x75']),
- ('\U0001d603', &['\x76']), ('\U0001d604', &['\x77']), ('\U0001d605', &['\x78']),
- ('\U0001d606', &['\x79']), ('\U0001d607', &['\x7a']), ('\U0001d608', &['\x41']),
- ('\U0001d609', &['\x42']), ('\U0001d60a', &['\x43']), ('\U0001d60b', &['\x44']),
- ('\U0001d60c', &['\x45']), ('\U0001d60d', &['\x46']), ('\U0001d60e', &['\x47']),
- ('\U0001d60f', &['\x48']), ('\U0001d610', &['\x49']), ('\U0001d611', &['\x4a']),
- ('\U0001d612', &['\x4b']), ('\U0001d613', &['\x4c']), ('\U0001d614', &['\x4d']),
- ('\U0001d615', &['\x4e']), ('\U0001d616', &['\x4f']), ('\U0001d617', &['\x50']),
- ('\U0001d618', &['\x51']), ('\U0001d619', &['\x52']), ('\U0001d61a', &['\x53']),
- ('\U0001d61b', &['\x54']), ('\U0001d61c', &['\x55']), ('\U0001d61d', &['\x56']),
- ('\U0001d61e', &['\x57']), ('\U0001d61f', &['\x58']), ('\U0001d620', &['\x59']),
- ('\U0001d621', &['\x5a']), ('\U0001d622', &['\x61']), ('\U0001d623', &['\x62']),
- ('\U0001d624', &['\x63']), ('\U0001d625', &['\x64']), ('\U0001d626', &['\x65']),
- ('\U0001d627', &['\x66']), ('\U0001d628', &['\x67']), ('\U0001d629', &['\x68']),
- ('\U0001d62a', &['\x69']), ('\U0001d62b', &['\x6a']), ('\U0001d62c', &['\x6b']),
- ('\U0001d62d', &['\x6c']), ('\U0001d62e', &['\x6d']), ('\U0001d62f', &['\x6e']),
- ('\U0001d630', &['\x6f']), ('\U0001d631', &['\x70']), ('\U0001d632', &['\x71']),
- ('\U0001d633', &['\x72']), ('\U0001d634', &['\x73']), ('\U0001d635', &['\x74']),
- ('\U0001d636', &['\x75']), ('\U0001d637', &['\x76']), ('\U0001d638', &['\x77']),
- ('\U0001d639', &['\x78']), ('\U0001d63a', &['\x79']), ('\U0001d63b', &['\x7a']),
- ('\U0001d63c', &['\x41']), ('\U0001d63d', &['\x42']), ('\U0001d63e', &['\x43']),
- ('\U0001d63f', &['\x44']), ('\U0001d640', &['\x45']), ('\U0001d641', &['\x46']),
- ('\U0001d642', &['\x47']), ('\U0001d643', &['\x48']), ('\U0001d644', &['\x49']),
- ('\U0001d645', &['\x4a']), ('\U0001d646', &['\x4b']), ('\U0001d647', &['\x4c']),
- ('\U0001d648', &['\x4d']), ('\U0001d649', &['\x4e']), ('\U0001d64a', &['\x4f']),
- ('\U0001d64b', &['\x50']), ('\U0001d64c', &['\x51']), ('\U0001d64d', &['\x52']),
- ('\U0001d64e', &['\x53']), ('\U0001d64f', &['\x54']), ('\U0001d650', &['\x55']),
- ('\U0001d651', &['\x56']), ('\U0001d652', &['\x57']), ('\U0001d653', &['\x58']),
- ('\U0001d654', &['\x59']), ('\U0001d655', &['\x5a']), ('\U0001d656', &['\x61']),
- ('\U0001d657', &['\x62']), ('\U0001d658', &['\x63']), ('\U0001d659', &['\x64']),
- ('\U0001d65a', &['\x65']), ('\U0001d65b', &['\x66']), ('\U0001d65c', &['\x67']),
- ('\U0001d65d', &['\x68']), ('\U0001d65e', &['\x69']), ('\U0001d65f', &['\x6a']),
- ('\U0001d660', &['\x6b']), ('\U0001d661', &['\x6c']), ('\U0001d662', &['\x6d']),
- ('\U0001d663', &['\x6e']), ('\U0001d664', &['\x6f']), ('\U0001d665', &['\x70']),
- ('\U0001d666', &['\x71']), ('\U0001d667', &['\x72']), ('\U0001d668', &['\x73']),
- ('\U0001d669', &['\x74']), ('\U0001d66a', &['\x75']), ('\U0001d66b', &['\x76']),
- ('\U0001d66c', &['\x77']), ('\U0001d66d', &['\x78']), ('\U0001d66e', &['\x79']),
- ('\U0001d66f', &['\x7a']), ('\U0001d670', &['\x41']), ('\U0001d671', &['\x42']),
- ('\U0001d672', &['\x43']), ('\U0001d673', &['\x44']), ('\U0001d674', &['\x45']),
- ('\U0001d675', &['\x46']), ('\U0001d676', &['\x47']), ('\U0001d677', &['\x48']),
- ('\U0001d678', &['\x49']), ('\U0001d679', &['\x4a']), ('\U0001d67a', &['\x4b']),
- ('\U0001d67b', &['\x4c']), ('\U0001d67c', &['\x4d']), ('\U0001d67d', &['\x4e']),
- ('\U0001d67e', &['\x4f']), ('\U0001d67f', &['\x50']), ('\U0001d680', &['\x51']),
- ('\U0001d681', &['\x52']), ('\U0001d682', &['\x53']), ('\U0001d683', &['\x54']),
- ('\U0001d684', &['\x55']), ('\U0001d685', &['\x56']), ('\U0001d686', &['\x57']),
- ('\U0001d687', &['\x58']), ('\U0001d688', &['\x59']), ('\U0001d689', &['\x5a']),
- ('\U0001d68a', &['\x61']), ('\U0001d68b', &['\x62']), ('\U0001d68c', &['\x63']),
- ('\U0001d68d', &['\x64']), ('\U0001d68e', &['\x65']), ('\U0001d68f', &['\x66']),
- ('\U0001d690', &['\x67']), ('\U0001d691', &['\x68']), ('\U0001d692', &['\x69']),
- ('\U0001d693', &['\x6a']), ('\U0001d694', &['\x6b']), ('\U0001d695', &['\x6c']),
- ('\U0001d696', &['\x6d']), ('\U0001d697', &['\x6e']), ('\U0001d698', &['\x6f']),
- ('\U0001d699', &['\x70']), ('\U0001d69a', &['\x71']), ('\U0001d69b', &['\x72']),
- ('\U0001d69c', &['\x73']), ('\U0001d69d', &['\x74']), ('\U0001d69e', &['\x75']),
- ('\U0001d69f', &['\x76']), ('\U0001d6a0', &['\x77']), ('\U0001d6a1', &['\x78']),
- ('\U0001d6a2', &['\x79']), ('\U0001d6a3', &['\x7a']), ('\U0001d6a4', &['\u0131']),
- ('\U0001d6a5', &['\u0237']), ('\U0001d6a8', &['\u0391']), ('\U0001d6a9', &['\u0392']),
- ('\U0001d6aa', &['\u0393']), ('\U0001d6ab', &['\u0394']), ('\U0001d6ac', &['\u0395']),
- ('\U0001d6ad', &['\u0396']), ('\U0001d6ae', &['\u0397']), ('\U0001d6af', &['\u0398']),
- ('\U0001d6b0', &['\u0399']), ('\U0001d6b1', &['\u039a']), ('\U0001d6b2', &['\u039b']),
- ('\U0001d6b3', &['\u039c']), ('\U0001d6b4', &['\u039d']), ('\U0001d6b5', &['\u039e']),
- ('\U0001d6b6', &['\u039f']), ('\U0001d6b7', &['\u03a0']), ('\U0001d6b8', &['\u03a1']),
- ('\U0001d6b9', &['\u03f4']), ('\U0001d6ba', &['\u03a3']), ('\U0001d6bb', &['\u03a4']),
- ('\U0001d6bc', &['\u03a5']), ('\U0001d6bd', &['\u03a6']), ('\U0001d6be', &['\u03a7']),
- ('\U0001d6bf', &['\u03a8']), ('\U0001d6c0', &['\u03a9']), ('\U0001d6c1', &['\u2207']),
- ('\U0001d6c2', &['\u03b1']), ('\U0001d6c3', &['\u03b2']), ('\U0001d6c4', &['\u03b3']),
- ('\U0001d6c5', &['\u03b4']), ('\U0001d6c6', &['\u03b5']), ('\U0001d6c7', &['\u03b6']),
- ('\U0001d6c8', &['\u03b7']), ('\U0001d6c9', &['\u03b8']), ('\U0001d6ca', &['\u03b9']),
- ('\U0001d6cb', &['\u03ba']), ('\U0001d6cc', &['\u03bb']), ('\U0001d6cd', &['\u03bc']),
- ('\U0001d6ce', &['\u03bd']), ('\U0001d6cf', &['\u03be']), ('\U0001d6d0', &['\u03bf']),
- ('\U0001d6d1', &['\u03c0']), ('\U0001d6d2', &['\u03c1']), ('\U0001d6d3', &['\u03c2']),
- ('\U0001d6d4', &['\u03c3']), ('\U0001d6d5', &['\u03c4']), ('\U0001d6d6', &['\u03c5']),
- ('\U0001d6d7', &['\u03c6']), ('\U0001d6d8', &['\u03c7']), ('\U0001d6d9', &['\u03c8']),
- ('\U0001d6da', &['\u03c9']), ('\U0001d6db', &['\u2202']), ('\U0001d6dc', &['\u03f5']),
- ('\U0001d6dd', &['\u03d1']), ('\U0001d6de', &['\u03f0']), ('\U0001d6df', &['\u03d5']),
- ('\U0001d6e0', &['\u03f1']), ('\U0001d6e1', &['\u03d6']), ('\U0001d6e2', &['\u0391']),
- ('\U0001d6e3', &['\u0392']), ('\U0001d6e4', &['\u0393']), ('\U0001d6e5', &['\u0394']),
- ('\U0001d6e6', &['\u0395']), ('\U0001d6e7', &['\u0396']), ('\U0001d6e8', &['\u0397']),
- ('\U0001d6e9', &['\u0398']), ('\U0001d6ea', &['\u0399']), ('\U0001d6eb', &['\u039a']),
- ('\U0001d6ec', &['\u039b']), ('\U0001d6ed', &['\u039c']), ('\U0001d6ee', &['\u039d']),
- ('\U0001d6ef', &['\u039e']), ('\U0001d6f0', &['\u039f']), ('\U0001d6f1', &['\u03a0']),
- ('\U0001d6f2', &['\u03a1']), ('\U0001d6f3', &['\u03f4']), ('\U0001d6f4', &['\u03a3']),
- ('\U0001d6f5', &['\u03a4']), ('\U0001d6f6', &['\u03a5']), ('\U0001d6f7', &['\u03a6']),
- ('\U0001d6f8', &['\u03a7']), ('\U0001d6f9', &['\u03a8']), ('\U0001d6fa', &['\u03a9']),
- ('\U0001d6fb', &['\u2207']), ('\U0001d6fc', &['\u03b1']), ('\U0001d6fd', &['\u03b2']),
- ('\U0001d6fe', &['\u03b3']), ('\U0001d6ff', &['\u03b4']), ('\U0001d700', &['\u03b5']),
- ('\U0001d701', &['\u03b6']), ('\U0001d702', &['\u03b7']), ('\U0001d703', &['\u03b8']),
- ('\U0001d704', &['\u03b9']), ('\U0001d705', &['\u03ba']), ('\U0001d706', &['\u03bb']),
- ('\U0001d707', &['\u03bc']), ('\U0001d708', &['\u03bd']), ('\U0001d709', &['\u03be']),
- ('\U0001d70a', &['\u03bf']), ('\U0001d70b', &['\u03c0']), ('\U0001d70c', &['\u03c1']),
- ('\U0001d70d', &['\u03c2']), ('\U0001d70e', &['\u03c3']), ('\U0001d70f', &['\u03c4']),
- ('\U0001d710', &['\u03c5']), ('\U0001d711', &['\u03c6']), ('\U0001d712', &['\u03c7']),
- ('\U0001d713', &['\u03c8']), ('\U0001d714', &['\u03c9']), ('\U0001d715', &['\u2202']),
- ('\U0001d716', &['\u03f5']), ('\U0001d717', &['\u03d1']), ('\U0001d718', &['\u03f0']),
- ('\U0001d719', &['\u03d5']), ('\U0001d71a', &['\u03f1']), ('\U0001d71b', &['\u03d6']),
- ('\U0001d71c', &['\u0391']), ('\U0001d71d', &['\u0392']), ('\U0001d71e', &['\u0393']),
- ('\U0001d71f', &['\u0394']), ('\U0001d720', &['\u0395']), ('\U0001d721', &['\u0396']),
- ('\U0001d722', &['\u0397']), ('\U0001d723', &['\u0398']), ('\U0001d724', &['\u0399']),
- ('\U0001d725', &['\u039a']), ('\U0001d726', &['\u039b']), ('\U0001d727', &['\u039c']),
- ('\U0001d728', &['\u039d']), ('\U0001d729', &['\u039e']), ('\U0001d72a', &['\u039f']),
- ('\U0001d72b', &['\u03a0']), ('\U0001d72c', &['\u03a1']), ('\U0001d72d', &['\u03f4']),
- ('\U0001d72e', &['\u03a3']), ('\U0001d72f', &['\u03a4']), ('\U0001d730', &['\u03a5']),
- ('\U0001d731', &['\u03a6']), ('\U0001d732', &['\u03a7']), ('\U0001d733', &['\u03a8']),
- ('\U0001d734', &['\u03a9']), ('\U0001d735', &['\u2207']), ('\U0001d736', &['\u03b1']),
- ('\U0001d737', &['\u03b2']), ('\U0001d738', &['\u03b3']), ('\U0001d739', &['\u03b4']),
- ('\U0001d73a', &['\u03b5']), ('\U0001d73b', &['\u03b6']), ('\U0001d73c', &['\u03b7']),
- ('\U0001d73d', &['\u03b8']), ('\U0001d73e', &['\u03b9']), ('\U0001d73f', &['\u03ba']),
- ('\U0001d740', &['\u03bb']), ('\U0001d741', &['\u03bc']), ('\U0001d742', &['\u03bd']),
- ('\U0001d743', &['\u03be']), ('\U0001d744', &['\u03bf']), ('\U0001d745', &['\u03c0']),
- ('\U0001d746', &['\u03c1']), ('\U0001d747', &['\u03c2']), ('\U0001d748', &['\u03c3']),
- ('\U0001d749', &['\u03c4']), ('\U0001d74a', &['\u03c5']), ('\U0001d74b', &['\u03c6']),
- ('\U0001d74c', &['\u03c7']), ('\U0001d74d', &['\u03c8']), ('\U0001d74e', &['\u03c9']),
- ('\U0001d74f', &['\u2202']), ('\U0001d750', &['\u03f5']), ('\U0001d751', &['\u03d1']),
- ('\U0001d752', &['\u03f0']), ('\U0001d753', &['\u03d5']), ('\U0001d754', &['\u03f1']),
- ('\U0001d755', &['\u03d6']), ('\U0001d756', &['\u0391']), ('\U0001d757', &['\u0392']),
- ('\U0001d758', &['\u0393']), ('\U0001d759', &['\u0394']), ('\U0001d75a', &['\u0395']),
- ('\U0001d75b', &['\u0396']), ('\U0001d75c', &['\u0397']), ('\U0001d75d', &['\u0398']),
- ('\U0001d75e', &['\u0399']), ('\U0001d75f', &['\u039a']), ('\U0001d760', &['\u039b']),
- ('\U0001d761', &['\u039c']), ('\U0001d762', &['\u039d']), ('\U0001d763', &['\u039e']),
- ('\U0001d764', &['\u039f']), ('\U0001d765', &['\u03a0']), ('\U0001d766', &['\u03a1']),
- ('\U0001d767', &['\u03f4']), ('\U0001d768', &['\u03a3']), ('\U0001d769', &['\u03a4']),
- ('\U0001d76a', &['\u03a5']), ('\U0001d76b', &['\u03a6']), ('\U0001d76c', &['\u03a7']),
- ('\U0001d76d', &['\u03a8']), ('\U0001d76e', &['\u03a9']), ('\U0001d76f', &['\u2207']),
- ('\U0001d770', &['\u03b1']), ('\U0001d771', &['\u03b2']), ('\U0001d772', &['\u03b3']),
- ('\U0001d773', &['\u03b4']), ('\U0001d774', &['\u03b5']), ('\U0001d775', &['\u03b6']),
- ('\U0001d776', &['\u03b7']), ('\U0001d777', &['\u03b8']), ('\U0001d778', &['\u03b9']),
- ('\U0001d779', &['\u03ba']), ('\U0001d77a', &['\u03bb']), ('\U0001d77b', &['\u03bc']),
- ('\U0001d77c', &['\u03bd']), ('\U0001d77d', &['\u03be']), ('\U0001d77e', &['\u03bf']),
- ('\U0001d77f', &['\u03c0']), ('\U0001d780', &['\u03c1']), ('\U0001d781', &['\u03c2']),
- ('\U0001d782', &['\u03c3']), ('\U0001d783', &['\u03c4']), ('\U0001d784', &['\u03c5']),
- ('\U0001d785', &['\u03c6']), ('\U0001d786', &['\u03c7']), ('\U0001d787', &['\u03c8']),
- ('\U0001d788', &['\u03c9']), ('\U0001d789', &['\u2202']), ('\U0001d78a', &['\u03f5']),
- ('\U0001d78b', &['\u03d1']), ('\U0001d78c', &['\u03f0']), ('\U0001d78d', &['\u03d5']),
- ('\U0001d78e', &['\u03f1']), ('\U0001d78f', &['\u03d6']), ('\U0001d790', &['\u0391']),
- ('\U0001d791', &['\u0392']), ('\U0001d792', &['\u0393']), ('\U0001d793', &['\u0394']),
- ('\U0001d794', &['\u0395']), ('\U0001d795', &['\u0396']), ('\U0001d796', &['\u0397']),
- ('\U0001d797', &['\u0398']), ('\U0001d798', &['\u0399']), ('\U0001d799', &['\u039a']),
- ('\U0001d79a', &['\u039b']), ('\U0001d79b', &['\u039c']), ('\U0001d79c', &['\u039d']),
- ('\U0001d79d', &['\u039e']), ('\U0001d79e', &['\u039f']), ('\U0001d79f', &['\u03a0']),
- ('\U0001d7a0', &['\u03a1']), ('\U0001d7a1', &['\u03f4']), ('\U0001d7a2', &['\u03a3']),
- ('\U0001d7a3', &['\u03a4']), ('\U0001d7a4', &['\u03a5']), ('\U0001d7a5', &['\u03a6']),
- ('\U0001d7a6', &['\u03a7']), ('\U0001d7a7', &['\u03a8']), ('\U0001d7a8', &['\u03a9']),
- ('\U0001d7a9', &['\u2207']), ('\U0001d7aa', &['\u03b1']), ('\U0001d7ab', &['\u03b2']),
- ('\U0001d7ac', &['\u03b3']), ('\U0001d7ad', &['\u03b4']), ('\U0001d7ae', &['\u03b5']),
- ('\U0001d7af', &['\u03b6']), ('\U0001d7b0', &['\u03b7']), ('\U0001d7b1', &['\u03b8']),
- ('\U0001d7b2', &['\u03b9']), ('\U0001d7b3', &['\u03ba']), ('\U0001d7b4', &['\u03bb']),
- ('\U0001d7b5', &['\u03bc']), ('\U0001d7b6', &['\u03bd']), ('\U0001d7b7', &['\u03be']),
- ('\U0001d7b8', &['\u03bf']), ('\U0001d7b9', &['\u03c0']), ('\U0001d7ba', &['\u03c1']),
- ('\U0001d7bb', &['\u03c2']), ('\U0001d7bc', &['\u03c3']), ('\U0001d7bd', &['\u03c4']),
- ('\U0001d7be', &['\u03c5']), ('\U0001d7bf', &['\u03c6']), ('\U0001d7c0', &['\u03c7']),
- ('\U0001d7c1', &['\u03c8']), ('\U0001d7c2', &['\u03c9']), ('\U0001d7c3', &['\u2202']),
- ('\U0001d7c4', &['\u03f5']), ('\U0001d7c5', &['\u03d1']), ('\U0001d7c6', &['\u03f0']),
- ('\U0001d7c7', &['\u03d5']), ('\U0001d7c8', &['\u03f1']), ('\U0001d7c9', &['\u03d6']),
- ('\U0001d7ca', &['\u03dc']), ('\U0001d7cb', &['\u03dd']), ('\U0001d7ce', &['\x30']),
- ('\U0001d7cf', &['\x31']), ('\U0001d7d0', &['\x32']), ('\U0001d7d1', &['\x33']),
- ('\U0001d7d2', &['\x34']), ('\U0001d7d3', &['\x35']), ('\U0001d7d4', &['\x36']),
- ('\U0001d7d5', &['\x37']), ('\U0001d7d6', &['\x38']), ('\U0001d7d7', &['\x39']),
- ('\U0001d7d8', &['\x30']), ('\U0001d7d9', &['\x31']), ('\U0001d7da', &['\x32']),
- ('\U0001d7db', &['\x33']), ('\U0001d7dc', &['\x34']), ('\U0001d7dd', &['\x35']),
- ('\U0001d7de', &['\x36']), ('\U0001d7df', &['\x37']), ('\U0001d7e0', &['\x38']),
- ('\U0001d7e1', &['\x39']), ('\U0001d7e2', &['\x30']), ('\U0001d7e3', &['\x31']),
- ('\U0001d7e4', &['\x32']), ('\U0001d7e5', &['\x33']), ('\U0001d7e6', &['\x34']),
- ('\U0001d7e7', &['\x35']), ('\U0001d7e8', &['\x36']), ('\U0001d7e9', &['\x37']),
- ('\U0001d7ea', &['\x38']), ('\U0001d7eb', &['\x39']), ('\U0001d7ec', &['\x30']),
- ('\U0001d7ed', &['\x31']), ('\U0001d7ee', &['\x32']), ('\U0001d7ef', &['\x33']),
- ('\U0001d7f0', &['\x34']), ('\U0001d7f1', &['\x35']), ('\U0001d7f2', &['\x36']),
- ('\U0001d7f3', &['\x37']), ('\U0001d7f4', &['\x38']), ('\U0001d7f5', &['\x39']),
- ('\U0001d7f6', &['\x30']), ('\U0001d7f7', &['\x31']), ('\U0001d7f8', &['\x32']),
- ('\U0001d7f9', &['\x33']), ('\U0001d7fa', &['\x34']), ('\U0001d7fb', &['\x35']),
- ('\U0001d7fc', &['\x36']), ('\U0001d7fd', &['\x37']), ('\U0001d7fe', &['\x38']),
- ('\U0001d7ff', &['\x39']), ('\U0001ee00', &['\u0627']), ('\U0001ee01', &['\u0628']),
- ('\U0001ee02', &['\u062c']), ('\U0001ee03', &['\u062f']), ('\U0001ee05', &['\u0648']),
- ('\U0001ee06', &['\u0632']), ('\U0001ee07', &['\u062d']), ('\U0001ee08', &['\u0637']),
- ('\U0001ee09', &['\u064a']), ('\U0001ee0a', &['\u0643']), ('\U0001ee0b', &['\u0644']),
- ('\U0001ee0c', &['\u0645']), ('\U0001ee0d', &['\u0646']), ('\U0001ee0e', &['\u0633']),
- ('\U0001ee0f', &['\u0639']), ('\U0001ee10', &['\u0641']), ('\U0001ee11', &['\u0635']),
- ('\U0001ee12', &['\u0642']), ('\U0001ee13', &['\u0631']), ('\U0001ee14', &['\u0634']),
- ('\U0001ee15', &['\u062a']), ('\U0001ee16', &['\u062b']), ('\U0001ee17', &['\u062e']),
- ('\U0001ee18', &['\u0630']), ('\U0001ee19', &['\u0636']), ('\U0001ee1a', &['\u0638']),
- ('\U0001ee1b', &['\u063a']), ('\U0001ee1c', &['\u066e']), ('\U0001ee1d', &['\u06ba']),
- ('\U0001ee1e', &['\u06a1']), ('\U0001ee1f', &['\u066f']), ('\U0001ee21', &['\u0628']),
- ('\U0001ee22', &['\u062c']), ('\U0001ee24', &['\u0647']), ('\U0001ee27', &['\u062d']),
- ('\U0001ee29', &['\u064a']), ('\U0001ee2a', &['\u0643']), ('\U0001ee2b', &['\u0644']),
- ('\U0001ee2c', &['\u0645']), ('\U0001ee2d', &['\u0646']), ('\U0001ee2e', &['\u0633']),
- ('\U0001ee2f', &['\u0639']), ('\U0001ee30', &['\u0641']), ('\U0001ee31', &['\u0635']),
- ('\U0001ee32', &['\u0642']), ('\U0001ee34', &['\u0634']), ('\U0001ee35', &['\u062a']),
- ('\U0001ee36', &['\u062b']), ('\U0001ee37', &['\u062e']), ('\U0001ee39', &['\u0636']),
- ('\U0001ee3b', &['\u063a']), ('\U0001ee42', &['\u062c']), ('\U0001ee47', &['\u062d']),
- ('\U0001ee49', &['\u064a']), ('\U0001ee4b', &['\u0644']), ('\U0001ee4d', &['\u0646']),
- ('\U0001ee4e', &['\u0633']), ('\U0001ee4f', &['\u0639']), ('\U0001ee51', &['\u0635']),
- ('\U0001ee52', &['\u0642']), ('\U0001ee54', &['\u0634']), ('\U0001ee57', &['\u062e']),
- ('\U0001ee59', &['\u0636']), ('\U0001ee5b', &['\u063a']), ('\U0001ee5d', &['\u06ba']),
- ('\U0001ee5f', &['\u066f']), ('\U0001ee61', &['\u0628']), ('\U0001ee62', &['\u062c']),
- ('\U0001ee64', &['\u0647']), ('\U0001ee67', &['\u062d']), ('\U0001ee68', &['\u0637']),
- ('\U0001ee69', &['\u064a']), ('\U0001ee6a', &['\u0643']), ('\U0001ee6c', &['\u0645']),
- ('\U0001ee6d', &['\u0646']), ('\U0001ee6e', &['\u0633']), ('\U0001ee6f', &['\u0639']),
- ('\U0001ee70', &['\u0641']), ('\U0001ee71', &['\u0635']), ('\U0001ee72', &['\u0642']),
- ('\U0001ee74', &['\u0634']), ('\U0001ee75', &['\u062a']), ('\U0001ee76', &['\u062b']),
- ('\U0001ee77', &['\u062e']), ('\U0001ee79', &['\u0636']), ('\U0001ee7a', &['\u0638']),
- ('\U0001ee7b', &['\u063a']), ('\U0001ee7c', &['\u066e']), ('\U0001ee7e', &['\u06a1']),
- ('\U0001ee80', &['\u0627']), ('\U0001ee81', &['\u0628']), ('\U0001ee82', &['\u062c']),
- ('\U0001ee83', &['\u062f']), ('\U0001ee84', &['\u0647']), ('\U0001ee85', &['\u0648']),
- ('\U0001ee86', &['\u0632']), ('\U0001ee87', &['\u062d']), ('\U0001ee88', &['\u0637']),
- ('\U0001ee89', &['\u064a']), ('\U0001ee8b', &['\u0644']), ('\U0001ee8c', &['\u0645']),
- ('\U0001ee8d', &['\u0646']), ('\U0001ee8e', &['\u0633']), ('\U0001ee8f', &['\u0639']),
- ('\U0001ee90', &['\u0641']), ('\U0001ee91', &['\u0635']), ('\U0001ee92', &['\u0642']),
- ('\U0001ee93', &['\u0631']), ('\U0001ee94', &['\u0634']), ('\U0001ee95', &['\u062a']),
- ('\U0001ee96', &['\u062b']), ('\U0001ee97', &['\u062e']), ('\U0001ee98', &['\u0630']),
- ('\U0001ee99', &['\u0636']), ('\U0001ee9a', &['\u0638']), ('\U0001ee9b', &['\u063a']),
- ('\U0001eea1', &['\u0628']), ('\U0001eea2', &['\u062c']), ('\U0001eea3', &['\u062f']),
- ('\U0001eea5', &['\u0648']), ('\U0001eea6', &['\u0632']), ('\U0001eea7', &['\u062d']),
- ('\U0001eea8', &['\u0637']), ('\U0001eea9', &['\u064a']), ('\U0001eeab', &['\u0644']),
- ('\U0001eeac', &['\u0645']), ('\U0001eead', &['\u0646']), ('\U0001eeae', &['\u0633']),
- ('\U0001eeaf', &['\u0639']), ('\U0001eeb0', &['\u0641']), ('\U0001eeb1', &['\u0635']),
- ('\U0001eeb2', &['\u0642']), ('\U0001eeb3', &['\u0631']), ('\U0001eeb4', &['\u0634']),
- ('\U0001eeb5', &['\u062a']), ('\U0001eeb6', &['\u062b']), ('\U0001eeb7', &['\u062e']),
- ('\U0001eeb8', &['\u0630']), ('\U0001eeb9', &['\u0636']), ('\U0001eeba', &['\u0638']),
- ('\U0001eebb', &['\u063a']), ('\U0001f100', &['\x30', '\x2e']), ('\U0001f101', &['\x30',
- '\x2c']), ('\U0001f102', &['\x31', '\x2c']), ('\U0001f103', &['\x32', '\x2c']),
- ('\U0001f104', &['\x33', '\x2c']), ('\U0001f105', &['\x34', '\x2c']), ('\U0001f106',
- &['\x35', '\x2c']), ('\U0001f107', &['\x36', '\x2c']), ('\U0001f108', &['\x37', '\x2c']),
- ('\U0001f109', &['\x38', '\x2c']), ('\U0001f10a', &['\x39', '\x2c']), ('\U0001f110',
- &['\x28', '\x41', '\x29']), ('\U0001f111', &['\x28', '\x42', '\x29']), ('\U0001f112',
- &['\x28', '\x43', '\x29']), ('\U0001f113', &['\x28', '\x44', '\x29']), ('\U0001f114',
- &['\x28', '\x45', '\x29']), ('\U0001f115', &['\x28', '\x46', '\x29']), ('\U0001f116',
- &['\x28', '\x47', '\x29']), ('\U0001f117', &['\x28', '\x48', '\x29']), ('\U0001f118',
- &['\x28', '\x49', '\x29']), ('\U0001f119', &['\x28', '\x4a', '\x29']), ('\U0001f11a',
- &['\x28', '\x4b', '\x29']), ('\U0001f11b', &['\x28', '\x4c', '\x29']), ('\U0001f11c',
- &['\x28', '\x4d', '\x29']), ('\U0001f11d', &['\x28', '\x4e', '\x29']), ('\U0001f11e',
- &['\x28', '\x4f', '\x29']), ('\U0001f11f', &['\x28', '\x50', '\x29']), ('\U0001f120',
- &['\x28', '\x51', '\x29']), ('\U0001f121', &['\x28', '\x52', '\x29']), ('\U0001f122',
- &['\x28', '\x53', '\x29']), ('\U0001f123', &['\x28', '\x54', '\x29']), ('\U0001f124',
- &['\x28', '\x55', '\x29']), ('\U0001f125', &['\x28', '\x56', '\x29']), ('\U0001f126',
- &['\x28', '\x57', '\x29']), ('\U0001f127', &['\x28', '\x58', '\x29']), ('\U0001f128',
- &['\x28', '\x59', '\x29']), ('\U0001f129', &['\x28', '\x5a', '\x29']), ('\U0001f12a',
- &['\u3014', '\x53', '\u3015']), ('\U0001f12b', &['\x43']), ('\U0001f12c', &['\x52']),
- ('\U0001f12d', &['\x43', '\x44']), ('\U0001f12e', &['\x57', '\x5a']), ('\U0001f130',
- &['\x41']), ('\U0001f131', &['\x42']), ('\U0001f132', &['\x43']), ('\U0001f133', &['\x44']),
- ('\U0001f134', &['\x45']), ('\U0001f135', &['\x46']), ('\U0001f136', &['\x47']),
- ('\U0001f137', &['\x48']), ('\U0001f138', &['\x49']), ('\U0001f139', &['\x4a']),
- ('\U0001f13a', &['\x4b']), ('\U0001f13b', &['\x4c']), ('\U0001f13c', &['\x4d']),
- ('\U0001f13d', &['\x4e']), ('\U0001f13e', &['\x4f']), ('\U0001f13f', &['\x50']),
- ('\U0001f140', &['\x51']), ('\U0001f141', &['\x52']), ('\U0001f142', &['\x53']),
- ('\U0001f143', &['\x54']), ('\U0001f144', &['\x55']), ('\U0001f145', &['\x56']),
- ('\U0001f146', &['\x57']), ('\U0001f147', &['\x58']), ('\U0001f148', &['\x59']),
- ('\U0001f149', &['\x5a']), ('\U0001f14a', &['\x48', '\x56']), ('\U0001f14b', &['\x4d',
- '\x56']), ('\U0001f14c', &['\x53', '\x44']), ('\U0001f14d', &['\x53', '\x53']),
- ('\U0001f14e', &['\x50', '\x50', '\x56']), ('\U0001f14f', &['\x57', '\x43']), ('\U0001f16a',
- &['\x4d', '\x43']), ('\U0001f16b', &['\x4d', '\x44']), ('\U0001f190', &['\x44', '\x4a']),
- ('\U0001f200', &['\u307b', '\u304b']), ('\U0001f201', &['\u30b3', '\u30b3']), ('\U0001f202',
- &['\u30b5']), ('\U0001f210', &['\u624b']), ('\U0001f211', &['\u5b57']), ('\U0001f212',
- &['\u53cc']), ('\U0001f213', &['\u30c7']), ('\U0001f214', &['\u4e8c']), ('\U0001f215',
- &['\u591a']), ('\U0001f216', &['\u89e3']), ('\U0001f217', &['\u5929']), ('\U0001f218',
- &['\u4ea4']), ('\U0001f219', &['\u6620']), ('\U0001f21a', &['\u7121']), ('\U0001f21b',
- &['\u6599']), ('\U0001f21c', &['\u524d']), ('\U0001f21d', &['\u5f8c']), ('\U0001f21e',
- &['\u518d']), ('\U0001f21f', &['\u65b0']), ('\U0001f220', &['\u521d']), ('\U0001f221',
- &['\u7d42']), ('\U0001f222', &['\u751f']), ('\U0001f223', &['\u8ca9']), ('\U0001f224',
- &['\u58f0']), ('\U0001f225', &['\u5439']), ('\U0001f226', &['\u6f14']), ('\U0001f227',
- &['\u6295']), ('\U0001f228', &['\u6355']), ('\U0001f229', &['\u4e00']), ('\U0001f22a',
- &['\u4e09']), ('\U0001f22b', &['\u904a']), ('\U0001f22c', &['\u5de6']), ('\U0001f22d',
- &['\u4e2d']), ('\U0001f22e', &['\u53f3']), ('\U0001f22f', &['\u6307']), ('\U0001f230',
- &['\u8d70']), ('\U0001f231', &['\u6253']), ('\U0001f232', &['\u7981']), ('\U0001f233',
- &['\u7a7a']), ('\U0001f234', &['\u5408']), ('\U0001f235', &['\u6e80']), ('\U0001f236',
- &['\u6709']), ('\U0001f237', &['\u6708']), ('\U0001f238', &['\u7533']), ('\U0001f239',
- &['\u5272']), ('\U0001f23a', &['\u55b6']), ('\U0001f240', &['\u3014', '\u672c', '\u3015']),
- ('\U0001f241', &['\u3014', '\u4e09', '\u3015']), ('\U0001f242', &['\u3014', '\u4e8c',
- '\u3015']), ('\U0001f243', &['\u3014', '\u5b89', '\u3015']), ('\U0001f244', &['\u3014',
- '\u70b9', '\u3015']), ('\U0001f245', &['\u3014', '\u6253', '\u3015']), ('\U0001f246',
- &['\u3014', '\u76d7', '\u3015']), ('\U0001f247', &['\u3014', '\u52dd', '\u3015']),
- ('\U0001f248', &['\u3014', '\u6557', '\u3015']), ('\U0001f250', &['\u5f97']), ('\U0001f251',
- &['\u53ef'])
- ];
-
-
- pub fn decompose_canonical(c: char, i: |char|) { d(c, i, false); }
-
- pub fn decompose_compatible(c: char, i: |char|) { d(c, i, true); }
-
- fn d(c: char, i: |char|, k: bool) {
- use iter::Iterator;
-
- // 7-bit ASCII never decomposes
- if c <= '\x7f' { i(c); return; }
-
- // Perform decomposition for Hangul
- if (c as u32) >= S_BASE && (c as u32) < (S_BASE + S_COUNT) {
- decompose_hangul(c, i);
- return;
- }
-
- // First check the canonical decompositions
- match bsearch_table(c, canonical_table) {
- Some(canon) => {
- for x in canon.iter() {
- d(*x, |b| i(b), k);
- }
- return;
- }
- None => ()
- }
-
- // Bottom out if we're not doing compat.
- if !k { i(c); return; }
-
- // Then check the compatibility decompositions
- match bsearch_table(c, compatibility_table) {
- Some(compat) => {
- for x in compat.iter() {
- d(*x, |b| i(b), k);
- }
- return;
- }
- None => ()
- }
-
- // Finally bottom out.
- i(c);
- }
-
- // Constants from Unicode 6.2.0 Section 3.12 Conjoining Jamo Behavior
- static S_BASE: u32 = 0xAC00;
- static L_BASE: u32 = 0x1100;
- static V_BASE: u32 = 0x1161;
- static T_BASE: u32 = 0x11A7;
- static L_COUNT: u32 = 19;
- static V_COUNT: u32 = 21;
- static T_COUNT: u32 = 28;
- static N_COUNT: u32 = (V_COUNT * T_COUNT);
- static S_COUNT: u32 = (L_COUNT * N_COUNT);
-
- // Decompose a precomposed Hangul syllable
- fn decompose_hangul(s: char, f: |char|) {
- use mem::transmute;
-
- let si = s as u32 - S_BASE;
-
- let li = si / N_COUNT;
- unsafe {
- f(transmute(L_BASE + li));
-
- let vi = (si % N_COUNT) / T_COUNT;
- f(transmute(V_BASE + vi));
-
- let ti = si % T_COUNT;
- if ti > 0 {
- f(transmute(T_BASE + ti));
- }
- }
- }
-}
-
-pub mod derived_property {
- static Alphabetic_table : &'static [(char,char)] = &[
- ('\x41', '\x5a'), ('\x61', '\x7a'),
- ('\xaa', '\xaa'), ('\xb5', '\xb5'),
- ('\xba', '\xba'), ('\xc0', '\xd6'),
- ('\xd8', '\xf6'), ('\xf8', '\u01ba'),
- ('\u01bb', '\u01bb'), ('\u01bc', '\u01bf'),
- ('\u01c0', '\u01c3'), ('\u01c4', '\u0293'),
- ('\u0294', '\u0294'), ('\u0295', '\u02af'),
- ('\u02b0', '\u02c1'), ('\u02c6', '\u02d1'),
- ('\u02e0', '\u02e4'), ('\u02ec', '\u02ec'),
- ('\u02ee', '\u02ee'), ('\u0345', '\u0345'),
- ('\u0370', '\u0373'), ('\u0374', '\u0374'),
- ('\u0376', '\u0377'), ('\u037a', '\u037a'),
- ('\u037b', '\u037d'), ('\u0386', '\u0386'),
- ('\u0388', '\u038a'), ('\u038c', '\u038c'),
- ('\u038e', '\u03a1'), ('\u03a3', '\u03f5'),
- ('\u03f7', '\u0481'), ('\u048a', '\u0527'),
- ('\u0531', '\u0556'), ('\u0559', '\u0559'),
- ('\u0561', '\u0587'), ('\u05b0', '\u05bd'),
- ('\u05bf', '\u05bf'), ('\u05c1', '\u05c2'),
- ('\u05c4', '\u05c5'), ('\u05c7', '\u05c7'),
- ('\u05d0', '\u05ea'), ('\u05f0', '\u05f2'),
- ('\u0610', '\u061a'), ('\u0620', '\u063f'),
- ('\u0640', '\u0640'), ('\u0641', '\u064a'),
- ('\u064b', '\u0657'), ('\u0659', '\u065f'),
- ('\u066e', '\u066f'), ('\u0670', '\u0670'),
- ('\u0671', '\u06d3'), ('\u06d5', '\u06d5'),
- ('\u06d6', '\u06dc'), ('\u06e1', '\u06e4'),
- ('\u06e5', '\u06e6'), ('\u06e7', '\u06e8'),
- ('\u06ed', '\u06ed'), ('\u06ee', '\u06ef'),
- ('\u06fa', '\u06fc'), ('\u06ff', '\u06ff'),
- ('\u0710', '\u0710'), ('\u0711', '\u0711'),
- ('\u0712', '\u072f'), ('\u0730', '\u073f'),
- ('\u074d', '\u07a5'), ('\u07a6', '\u07b0'),
- ('\u07b1', '\u07b1'), ('\u07ca', '\u07ea'),
- ('\u07f4', '\u07f5'), ('\u07fa', '\u07fa'),
- ('\u0800', '\u0815'), ('\u0816', '\u0817'),
- ('\u081a', '\u081a'), ('\u081b', '\u0823'),
- ('\u0824', '\u0824'), ('\u0825', '\u0827'),
- ('\u0828', '\u0828'), ('\u0829', '\u082c'),
- ('\u0840', '\u0858'), ('\u08a0', '\u08a0'),
- ('\u08a2', '\u08ac'), ('\u08e4', '\u08e9'),
- ('\u08f0', '\u08fe'), ('\u0900', '\u0902'),
- ('\u0903', '\u0903'), ('\u0904', '\u0939'),
- ('\u093a', '\u093a'), ('\u093b', '\u093b'),
- ('\u093d', '\u093d'), ('\u093e', '\u0940'),
- ('\u0941', '\u0948'), ('\u0949', '\u094c'),
- ('\u094e', '\u094f'), ('\u0950', '\u0950'),
- ('\u0955', '\u0957'), ('\u0958', '\u0961'),
- ('\u0962', '\u0963'), ('\u0971', '\u0971'),
- ('\u0972', '\u0977'), ('\u0979', '\u097f'),
- ('\u0981', '\u0981'), ('\u0982', '\u0983'),
- ('\u0985', '\u098c'), ('\u098f', '\u0990'),
- ('\u0993', '\u09a8'), ('\u09aa', '\u09b0'),
- ('\u09b2', '\u09b2'), ('\u09b6', '\u09b9'),
- ('\u09bd', '\u09bd'), ('\u09be', '\u09c0'),
- ('\u09c1', '\u09c4'), ('\u09c7', '\u09c8'),
- ('\u09cb', '\u09cc'), ('\u09ce', '\u09ce'),
- ('\u09d7', '\u09d7'), ('\u09dc', '\u09dd'),
- ('\u09df', '\u09e1'), ('\u09e2', '\u09e3'),
- ('\u09f0', '\u09f1'), ('\u0a01', '\u0a02'),
- ('\u0a03', '\u0a03'), ('\u0a05', '\u0a0a'),
- ('\u0a0f', '\u0a10'), ('\u0a13', '\u0a28'),
- ('\u0a2a', '\u0a30'), ('\u0a32', '\u0a33'),
- ('\u0a35', '\u0a36'), ('\u0a38', '\u0a39'),
- ('\u0a3e', '\u0a40'), ('\u0a41', '\u0a42'),
- ('\u0a47', '\u0a48'), ('\u0a4b', '\u0a4c'),
- ('\u0a51', '\u0a51'), ('\u0a59', '\u0a5c'),
- ('\u0a5e', '\u0a5e'), ('\u0a70', '\u0a71'),
- ('\u0a72', '\u0a74'), ('\u0a75', '\u0a75'),
- ('\u0a81', '\u0a82'), ('\u0a83', '\u0a83'),
- ('\u0a85', '\u0a8d'), ('\u0a8f', '\u0a91'),
- ('\u0a93', '\u0aa8'), ('\u0aaa', '\u0ab0'),
- ('\u0ab2', '\u0ab3'), ('\u0ab5', '\u0ab9'),
- ('\u0abd', '\u0abd'), ('\u0abe', '\u0ac0'),
- ('\u0ac1', '\u0ac5'), ('\u0ac7', '\u0ac8'),
- ('\u0ac9', '\u0ac9'), ('\u0acb', '\u0acc'),
- ('\u0ad0', '\u0ad0'), ('\u0ae0', '\u0ae1'),
- ('\u0ae2', '\u0ae3'), ('\u0b01', '\u0b01'),
- ('\u0b02', '\u0b03'), ('\u0b05', '\u0b0c'),
- ('\u0b0f', '\u0b10'), ('\u0b13', '\u0b28'),
- ('\u0b2a', '\u0b30'), ('\u0b32', '\u0b33'),
- ('\u0b35', '\u0b39'), ('\u0b3d', '\u0b3d'),
- ('\u0b3e', '\u0b3e'), ('\u0b3f', '\u0b3f'),
- ('\u0b40', '\u0b40'), ('\u0b41', '\u0b44'),
- ('\u0b47', '\u0b48'), ('\u0b4b', '\u0b4c'),
- ('\u0b56', '\u0b56'), ('\u0b57', '\u0b57'),
- ('\u0b5c', '\u0b5d'), ('\u0b5f', '\u0b61'),
- ('\u0b62', '\u0b63'), ('\u0b71', '\u0b71'),
- ('\u0b82', '\u0b82'), ('\u0b83', '\u0b83'),
- ('\u0b85', '\u0b8a'), ('\u0b8e', '\u0b90'),
- ('\u0b92', '\u0b95'), ('\u0b99', '\u0b9a'),
- ('\u0b9c', '\u0b9c'), ('\u0b9e', '\u0b9f'),
- ('\u0ba3', '\u0ba4'), ('\u0ba8', '\u0baa'),
- ('\u0bae', '\u0bb9'), ('\u0bbe', '\u0bbf'),
- ('\u0bc0', '\u0bc0'), ('\u0bc1', '\u0bc2'),
- ('\u0bc6', '\u0bc8'), ('\u0bca', '\u0bcc'),
- ('\u0bd0', '\u0bd0'), ('\u0bd7', '\u0bd7'),
- ('\u0c01', '\u0c03'), ('\u0c05', '\u0c0c'),
- ('\u0c0e', '\u0c10'), ('\u0c12', '\u0c28'),
- ('\u0c2a', '\u0c33'), ('\u0c35', '\u0c39'),
- ('\u0c3d', '\u0c3d'), ('\u0c3e', '\u0c40'),
- ('\u0c41', '\u0c44'), ('\u0c46', '\u0c48'),
- ('\u0c4a', '\u0c4c'), ('\u0c55', '\u0c56'),
- ('\u0c58', '\u0c59'), ('\u0c60', '\u0c61'),
- ('\u0c62', '\u0c63'), ('\u0c82', '\u0c83'),
- ('\u0c85', '\u0c8c'), ('\u0c8e', '\u0c90'),
- ('\u0c92', '\u0ca8'), ('\u0caa', '\u0cb3'),
- ('\u0cb5', '\u0cb9'), ('\u0cbd', '\u0cbd'),
- ('\u0cbe', '\u0cbe'), ('\u0cbf', '\u0cbf'),
- ('\u0cc0', '\u0cc4'), ('\u0cc6', '\u0cc6'),
- ('\u0cc7', '\u0cc8'), ('\u0cca', '\u0ccb'),
- ('\u0ccc', '\u0ccc'), ('\u0cd5', '\u0cd6'),
- ('\u0cde', '\u0cde'), ('\u0ce0', '\u0ce1'),
- ('\u0ce2', '\u0ce3'), ('\u0cf1', '\u0cf2'),
- ('\u0d02', '\u0d03'), ('\u0d05', '\u0d0c'),
- ('\u0d0e', '\u0d10'), ('\u0d12', '\u0d3a'),
- ('\u0d3d', '\u0d3d'), ('\u0d3e', '\u0d40'),
- ('\u0d41', '\u0d44'), ('\u0d46', '\u0d48'),
- ('\u0d4a', '\u0d4c'), ('\u0d4e', '\u0d4e'),
- ('\u0d57', '\u0d57'), ('\u0d60', '\u0d61'),
- ('\u0d62', '\u0d63'), ('\u0d7a', '\u0d7f'),
- ('\u0d82', '\u0d83'), ('\u0d85', '\u0d96'),
- ('\u0d9a', '\u0db1'), ('\u0db3', '\u0dbb'),
- ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'),
- ('\u0dcf', '\u0dd1'), ('\u0dd2', '\u0dd4'),
- ('\u0dd6', '\u0dd6'), ('\u0dd8', '\u0ddf'),
- ('\u0df2', '\u0df3'), ('\u0e01', '\u0e30'),
- ('\u0e31', '\u0e31'), ('\u0e32', '\u0e33'),
- ('\u0e34', '\u0e3a'), ('\u0e40', '\u0e45'),
- ('\u0e46', '\u0e46'), ('\u0e4d', '\u0e4d'),
- ('\u0e81', '\u0e82'), ('\u0e84', '\u0e84'),
- ('\u0e87', '\u0e88'), ('\u0e8a', '\u0e8a'),
- ('\u0e8d', '\u0e8d'), ('\u0e94', '\u0e97'),
- ('\u0e99', '\u0e9f'), ('\u0ea1', '\u0ea3'),
- ('\u0ea5', '\u0ea5'), ('\u0ea7', '\u0ea7'),
- ('\u0eaa', '\u0eab'), ('\u0ead', '\u0eb0'),
- ('\u0eb1', '\u0eb1'), ('\u0eb2', '\u0eb3'),
- ('\u0eb4', '\u0eb9'), ('\u0ebb', '\u0ebc'),
- ('\u0ebd', '\u0ebd'), ('\u0ec0', '\u0ec4'),
- ('\u0ec6', '\u0ec6'), ('\u0ecd', '\u0ecd'),
- ('\u0edc', '\u0edf'), ('\u0f00', '\u0f00'),
- ('\u0f40', '\u0f47'), ('\u0f49', '\u0f6c'),
- ('\u0f71', '\u0f7e'), ('\u0f7f', '\u0f7f'),
- ('\u0f80', '\u0f81'), ('\u0f88', '\u0f8c'),
- ('\u0f8d', '\u0f97'), ('\u0f99', '\u0fbc'),
- ('\u1000', '\u102a'), ('\u102b', '\u102c'),
- ('\u102d', '\u1030'), ('\u1031', '\u1031'),
- ('\u1032', '\u1036'), ('\u1038', '\u1038'),
- ('\u103b', '\u103c'), ('\u103d', '\u103e'),
- ('\u103f', '\u103f'), ('\u1050', '\u1055'),
- ('\u1056', '\u1057'), ('\u1058', '\u1059'),
- ('\u105a', '\u105d'), ('\u105e', '\u1060'),
- ('\u1061', '\u1061'), ('\u1062', '\u1062'),
- ('\u1065', '\u1066'), ('\u1067', '\u1068'),
- ('\u106e', '\u1070'), ('\u1071', '\u1074'),
- ('\u1075', '\u1081'), ('\u1082', '\u1082'),
- ('\u1083', '\u1084'), ('\u1085', '\u1086'),
- ('\u108e', '\u108e'), ('\u109c', '\u109c'),
- ('\u109d', '\u109d'), ('\u10a0', '\u10c5'),
- ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'),
- ('\u10d0', '\u10fa'), ('\u10fc', '\u10fc'),
- ('\u10fd', '\u1248'), ('\u124a', '\u124d'),
- ('\u1250', '\u1256'), ('\u1258', '\u1258'),
- ('\u125a', '\u125d'), ('\u1260', '\u1288'),
- ('\u128a', '\u128d'), ('\u1290', '\u12b0'),
- ('\u12b2', '\u12b5'), ('\u12b8', '\u12be'),
- ('\u12c0', '\u12c0'), ('\u12c2', '\u12c5'),
- ('\u12c8', '\u12d6'), ('\u12d8', '\u1310'),
- ('\u1312', '\u1315'), ('\u1318', '\u135a'),
- ('\u135f', '\u135f'), ('\u1380', '\u138f'),
- ('\u13a0', '\u13f4'), ('\u1401', '\u166c'),
- ('\u166f', '\u167f'), ('\u1681', '\u169a'),
- ('\u16a0', '\u16ea'), ('\u16ee', '\u16f0'),
- ('\u1700', '\u170c'), ('\u170e', '\u1711'),
- ('\u1712', '\u1713'), ('\u1720', '\u1731'),
- ('\u1732', '\u1733'), ('\u1740', '\u1751'),
- ('\u1752', '\u1753'), ('\u1760', '\u176c'),
- ('\u176e', '\u1770'), ('\u1772', '\u1773'),
- ('\u1780', '\u17b3'), ('\u17b6', '\u17b6'),
- ('\u17b7', '\u17bd'), ('\u17be', '\u17c5'),
- ('\u17c6', '\u17c6'), ('\u17c7', '\u17c8'),
- ('\u17d7', '\u17d7'), ('\u17dc', '\u17dc'),
- ('\u1820', '\u1842'), ('\u1843', '\u1843'),
- ('\u1844', '\u1877'), ('\u1880', '\u18a8'),
- ('\u18a9', '\u18a9'), ('\u18aa', '\u18aa'),
- ('\u18b0', '\u18f5'), ('\u1900', '\u191c'),
- ('\u1920', '\u1922'), ('\u1923', '\u1926'),
- ('\u1927', '\u1928'), ('\u1929', '\u192b'),
- ('\u1930', '\u1931'), ('\u1932', '\u1932'),
- ('\u1933', '\u1938'), ('\u1950', '\u196d'),
- ('\u1970', '\u1974'), ('\u1980', '\u19ab'),
- ('\u19b0', '\u19c0'), ('\u19c1', '\u19c7'),
- ('\u19c8', '\u19c9'), ('\u1a00', '\u1a16'),
- ('\u1a17', '\u1a18'), ('\u1a19', '\u1a1a'),
- ('\u1a1b', '\u1a1b'), ('\u1a20', '\u1a54'),
- ('\u1a55', '\u1a55'), ('\u1a56', '\u1a56'),
- ('\u1a57', '\u1a57'), ('\u1a58', '\u1a5e'),
- ('\u1a61', '\u1a61'), ('\u1a62', '\u1a62'),
- ('\u1a63', '\u1a64'), ('\u1a65', '\u1a6c'),
- ('\u1a6d', '\u1a72'), ('\u1a73', '\u1a74'),
- ('\u1aa7', '\u1aa7'), ('\u1b00', '\u1b03'),
- ('\u1b04', '\u1b04'), ('\u1b05', '\u1b33'),
- ('\u1b35', '\u1b35'), ('\u1b36', '\u1b3a'),
- ('\u1b3b', '\u1b3b'), ('\u1b3c', '\u1b3c'),
- ('\u1b3d', '\u1b41'), ('\u1b42', '\u1b42'),
- ('\u1b43', '\u1b43'), ('\u1b45', '\u1b4b'),
- ('\u1b80', '\u1b81'), ('\u1b82', '\u1b82'),
- ('\u1b83', '\u1ba0'), ('\u1ba1', '\u1ba1'),
- ('\u1ba2', '\u1ba5'), ('\u1ba6', '\u1ba7'),
- ('\u1ba8', '\u1ba9'), ('\u1bac', '\u1bad'),
- ('\u1bae', '\u1baf'), ('\u1bba', '\u1be5'),
- ('\u1be7', '\u1be7'), ('\u1be8', '\u1be9'),
- ('\u1bea', '\u1bec'), ('\u1bed', '\u1bed'),
- ('\u1bee', '\u1bee'), ('\u1bef', '\u1bf1'),
- ('\u1c00', '\u1c23'), ('\u1c24', '\u1c2b'),
- ('\u1c2c', '\u1c33'), ('\u1c34', '\u1c35'),
- ('\u1c4d', '\u1c4f'), ('\u1c5a', '\u1c77'),
- ('\u1c78', '\u1c7d'), ('\u1ce9', '\u1cec'),
- ('\u1cee', '\u1cf1'), ('\u1cf2', '\u1cf3'),
- ('\u1cf5', '\u1cf6'), ('\u1d00', '\u1d2b'),
- ('\u1d2c', '\u1d6a'), ('\u1d6b', '\u1d77'),
- ('\u1d78', '\u1d78'), ('\u1d79', '\u1d9a'),
- ('\u1d9b', '\u1dbf'), ('\u1e00', '\u1f15'),
- ('\u1f18', '\u1f1d'), ('\u1f20', '\u1f45'),
- ('\u1f48', '\u1f4d'), ('\u1f50', '\u1f57'),
- ('\u1f59', '\u1f59'), ('\u1f5b', '\u1f5b'),
- ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f7d'),
- ('\u1f80', '\u1fb4'), ('\u1fb6', '\u1fbc'),
- ('\u1fbe', '\u1fbe'), ('\u1fc2', '\u1fc4'),
- ('\u1fc6', '\u1fcc'), ('\u1fd0', '\u1fd3'),
- ('\u1fd6', '\u1fdb'), ('\u1fe0', '\u1fec'),
- ('\u1ff2', '\u1ff4'), ('\u1ff6', '\u1ffc'),
- ('\u2071', '\u2071'), ('\u207f', '\u207f'),
- ('\u2090', '\u209c'), ('\u2102', '\u2102'),
- ('\u2107', '\u2107'), ('\u210a', '\u2113'),
- ('\u2115', '\u2115'), ('\u2119', '\u211d'),
- ('\u2124', '\u2124'), ('\u2126', '\u2126'),
- ('\u2128', '\u2128'), ('\u212a', '\u212d'),
- ('\u212f', '\u2134'), ('\u2135', '\u2138'),
- ('\u2139', '\u2139'), ('\u213c', '\u213f'),
- ('\u2145', '\u2149'), ('\u214e', '\u214e'),
- ('\u2160', '\u2182'), ('\u2183', '\u2184'),
- ('\u2185', '\u2188'), ('\u24b6', '\u24e9'),
- ('\u2c00', '\u2c2e'), ('\u2c30', '\u2c5e'),
- ('\u2c60', '\u2c7b'), ('\u2c7c', '\u2c7d'),
- ('\u2c7e', '\u2ce4'), ('\u2ceb', '\u2cee'),
- ('\u2cf2', '\u2cf3'), ('\u2d00', '\u2d25'),
- ('\u2d27', '\u2d27'), ('\u2d2d', '\u2d2d'),
- ('\u2d30', '\u2d67'), ('\u2d6f', '\u2d6f'),
- ('\u2d80', '\u2d96'), ('\u2da0', '\u2da6'),
- ('\u2da8', '\u2dae'), ('\u2db0', '\u2db6'),
- ('\u2db8', '\u2dbe'), ('\u2dc0', '\u2dc6'),
- ('\u2dc8', '\u2dce'), ('\u2dd0', '\u2dd6'),
- ('\u2dd8', '\u2dde'), ('\u2de0', '\u2dff'),
- ('\u2e2f', '\u2e2f'), ('\u3005', '\u3005'),
- ('\u3006', '\u3006'), ('\u3007', '\u3007'),
- ('\u3021', '\u3029'), ('\u3031', '\u3035'),
- ('\u3038', '\u303a'), ('\u303b', '\u303b'),
- ('\u303c', '\u303c'), ('\u3041', '\u3096'),
- ('\u309d', '\u309e'), ('\u309f', '\u309f'),
- ('\u30a1', '\u30fa'), ('\u30fc', '\u30fe'),
- ('\u30ff', '\u30ff'), ('\u3105', '\u312d'),
- ('\u3131', '\u318e'), ('\u31a0', '\u31ba'),
- ('\u31f0', '\u31ff'), ('\u3400', '\u4db5'),
- ('\u4e00', '\u9fcc'), ('\ua000', '\ua014'),
- ('\ua015', '\ua015'), ('\ua016', '\ua48c'),
- ('\ua4d0', '\ua4f7'), ('\ua4f8', '\ua4fd'),
- ('\ua500', '\ua60b'), ('\ua60c', '\ua60c'),
- ('\ua610', '\ua61f'), ('\ua62a', '\ua62b'),
- ('\ua640', '\ua66d'), ('\ua66e', '\ua66e'),
- ('\ua674', '\ua67b'), ('\ua67f', '\ua67f'),
- ('\ua680', '\ua697'), ('\ua69f', '\ua69f'),
- ('\ua6a0', '\ua6e5'), ('\ua6e6', '\ua6ef'),
- ('\ua717', '\ua71f'), ('\ua722', '\ua76f'),
- ('\ua770', '\ua770'), ('\ua771', '\ua787'),
- ('\ua788', '\ua788'), ('\ua78b', '\ua78e'),
- ('\ua790', '\ua793'), ('\ua7a0', '\ua7aa'),
- ('\ua7f8', '\ua7f9'), ('\ua7fa', '\ua7fa'),
- ('\ua7fb', '\ua801'), ('\ua803', '\ua805'),
- ('\ua807', '\ua80a'), ('\ua80c', '\ua822'),
- ('\ua823', '\ua824'), ('\ua825', '\ua826'),
- ('\ua827', '\ua827'), ('\ua840', '\ua873'),
- ('\ua880', '\ua881'), ('\ua882', '\ua8b3'),
- ('\ua8b4', '\ua8c3'), ('\ua8f2', '\ua8f7'),
- ('\ua8fb', '\ua8fb'), ('\ua90a', '\ua925'),
- ('\ua926', '\ua92a'), ('\ua930', '\ua946'),
- ('\ua947', '\ua951'), ('\ua952', '\ua952'),
- ('\ua960', '\ua97c'), ('\ua980', '\ua982'),
- ('\ua983', '\ua983'), ('\ua984', '\ua9b2'),
- ('\ua9b4', '\ua9b5'), ('\ua9b6', '\ua9b9'),
- ('\ua9ba', '\ua9bb'), ('\ua9bc', '\ua9bc'),
- ('\ua9bd', '\ua9bf'), ('\ua9cf', '\ua9cf'),
- ('\uaa00', '\uaa28'), ('\uaa29', '\uaa2e'),
- ('\uaa2f', '\uaa30'), ('\uaa31', '\uaa32'),
- ('\uaa33', '\uaa34'), ('\uaa35', '\uaa36'),
- ('\uaa40', '\uaa42'), ('\uaa43', '\uaa43'),
- ('\uaa44', '\uaa4b'), ('\uaa4c', '\uaa4c'),
- ('\uaa4d', '\uaa4d'), ('\uaa60', '\uaa6f'),
- ('\uaa70', '\uaa70'), ('\uaa71', '\uaa76'),
- ('\uaa7a', '\uaa7a'), ('\uaa80', '\uaaaf'),
- ('\uaab0', '\uaab0'), ('\uaab1', '\uaab1'),
- ('\uaab2', '\uaab4'), ('\uaab5', '\uaab6'),
- ('\uaab7', '\uaab8'), ('\uaab9', '\uaabd'),
- ('\uaabe', '\uaabe'), ('\uaac0', '\uaac0'),
- ('\uaac2', '\uaac2'), ('\uaadb', '\uaadc'),
- ('\uaadd', '\uaadd'), ('\uaae0', '\uaaea'),
- ('\uaaeb', '\uaaeb'), ('\uaaec', '\uaaed'),
- ('\uaaee', '\uaaef'), ('\uaaf2', '\uaaf2'),
- ('\uaaf3', '\uaaf4'), ('\uaaf5', '\uaaf5'),
- ('\uab01', '\uab06'), ('\uab09', '\uab0e'),
- ('\uab11', '\uab16'), ('\uab20', '\uab26'),
- ('\uab28', '\uab2e'), ('\uabc0', '\uabe2'),
- ('\uabe3', '\uabe4'), ('\uabe5', '\uabe5'),
- ('\uabe6', '\uabe7'), ('\uabe8', '\uabe8'),
- ('\uabe9', '\uabea'), ('\uac00', '\ud7a3'),
- ('\ud7b0', '\ud7c6'), ('\ud7cb', '\ud7fb'),
- ('\uf900', '\ufa6d'), ('\ufa70', '\ufad9'),
- ('\ufb00', '\ufb06'), ('\ufb13', '\ufb17'),
- ('\ufb1d', '\ufb1d'), ('\ufb1e', '\ufb1e'),
- ('\ufb1f', '\ufb28'), ('\ufb2a', '\ufb36'),
- ('\ufb38', '\ufb3c'), ('\ufb3e', '\ufb3e'),
- ('\ufb40', '\ufb41'), ('\ufb43', '\ufb44'),
- ('\ufb46', '\ufbb1'), ('\ufbd3', '\ufd3d'),
- ('\ufd50', '\ufd8f'), ('\ufd92', '\ufdc7'),
- ('\ufdf0', '\ufdfb'), ('\ufe70', '\ufe74'),
- ('\ufe76', '\ufefc'), ('\uff21', '\uff3a'),
- ('\uff41', '\uff5a'), ('\uff66', '\uff6f'),
- ('\uff70', '\uff70'), ('\uff71', '\uff9d'),
- ('\uff9e', '\uff9f'), ('\uffa0', '\uffbe'),
- ('\uffc2', '\uffc7'), ('\uffca', '\uffcf'),
- ('\uffd2', '\uffd7'), ('\uffda', '\uffdc'),
- ('\U00010000', '\U0001000b'), ('\U0001000d', '\U00010026'),
- ('\U00010028', '\U0001003a'), ('\U0001003c', '\U0001003d'),
- ('\U0001003f', '\U0001004d'), ('\U00010050', '\U0001005d'),
- ('\U00010080', '\U000100fa'), ('\U00010140', '\U00010174'),
- ('\U00010280', '\U0001029c'), ('\U000102a0', '\U000102d0'),
- ('\U00010300', '\U0001031e'), ('\U00010330', '\U00010340'),
- ('\U00010341', '\U00010341'), ('\U00010342', '\U00010349'),
- ('\U0001034a', '\U0001034a'), ('\U00010380', '\U0001039d'),
- ('\U000103a0', '\U000103c3'), ('\U000103c8', '\U000103cf'),
- ('\U000103d1', '\U000103d5'), ('\U00010400', '\U0001044f'),
- ('\U00010450', '\U0001049d'), ('\U00010800', '\U00010805'),
- ('\U00010808', '\U00010808'), ('\U0001080a', '\U00010835'),
- ('\U00010837', '\U00010838'), ('\U0001083c', '\U0001083c'),
- ('\U0001083f', '\U00010855'), ('\U00010900', '\U00010915'),
- ('\U00010920', '\U00010939'), ('\U00010980', '\U000109b7'),
- ('\U000109be', '\U000109bf'), ('\U00010a00', '\U00010a00'),
- ('\U00010a01', '\U00010a03'), ('\U00010a05', '\U00010a06'),
- ('\U00010a0c', '\U00010a0f'), ('\U00010a10', '\U00010a13'),
- ('\U00010a15', '\U00010a17'), ('\U00010a19', '\U00010a33'),
- ('\U00010a60', '\U00010a7c'), ('\U00010b00', '\U00010b35'),
- ('\U00010b40', '\U00010b55'), ('\U00010b60', '\U00010b72'),
- ('\U00010c00', '\U00010c48'), ('\U00011000', '\U00011000'),
- ('\U00011001', '\U00011001'), ('\U00011002', '\U00011002'),
- ('\U00011003', '\U00011037'), ('\U00011038', '\U00011045'),
- ('\U00011082', '\U00011082'), ('\U00011083', '\U000110af'),
- ('\U000110b0', '\U000110b2'), ('\U000110b3', '\U000110b6'),
- ('\U000110b7', '\U000110b8'), ('\U000110d0', '\U000110e8'),
- ('\U00011100', '\U00011102'), ('\U00011103', '\U00011126'),
- ('\U00011127', '\U0001112b'), ('\U0001112c', '\U0001112c'),
- ('\U0001112d', '\U00011132'), ('\U00011180', '\U00011181'),
- ('\U00011182', '\U00011182'), ('\U00011183', '\U000111b2'),
- ('\U000111b3', '\U000111b5'), ('\U000111b6', '\U000111be'),
- ('\U000111bf', '\U000111bf'), ('\U000111c1', '\U000111c4'),
- ('\U00011680', '\U000116aa'), ('\U000116ab', '\U000116ab'),
- ('\U000116ac', '\U000116ac'), ('\U000116ad', '\U000116ad'),
- ('\U000116ae', '\U000116af'), ('\U000116b0', '\U000116b5'),
- ('\U00012000', '\U0001236e'), ('\U00012400', '\U00012462'),
- ('\U00013000', '\U0001342e'), ('\U00016800', '\U00016a38'),
- ('\U00016f00', '\U00016f44'), ('\U00016f50', '\U00016f50'),
- ('\U00016f51', '\U00016f7e'), ('\U00016f93', '\U00016f9f'),
- ('\U0001b000', '\U0001b001'), ('\U0001d400', '\U0001d454'),
- ('\U0001d456', '\U0001d49c'), ('\U0001d49e', '\U0001d49f'),
- ('\U0001d4a2', '\U0001d4a2'), ('\U0001d4a5', '\U0001d4a6'),
- ('\U0001d4a9', '\U0001d4ac'), ('\U0001d4ae', '\U0001d4b9'),
- ('\U0001d4bb', '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'),
- ('\U0001d4c5', '\U0001d505'), ('\U0001d507', '\U0001d50a'),
- ('\U0001d50d', '\U0001d514'), ('\U0001d516', '\U0001d51c'),
- ('\U0001d51e', '\U0001d539'), ('\U0001d53b', '\U0001d53e'),
- ('\U0001d540', '\U0001d544'), ('\U0001d546', '\U0001d546'),
- ('\U0001d54a', '\U0001d550'), ('\U0001d552', '\U0001d6a5'),
- ('\U0001d6a8', '\U0001d6c0'), ('\U0001d6c2', '\U0001d6da'),
- ('\U0001d6dc', '\U0001d6fa'), ('\U0001d6fc', '\U0001d714'),
- ('\U0001d716', '\U0001d734'), ('\U0001d736', '\U0001d74e'),
- ('\U0001d750', '\U0001d76e'), ('\U0001d770', '\U0001d788'),
- ('\U0001d78a', '\U0001d7a8'), ('\U0001d7aa', '\U0001d7c2'),
- ('\U0001d7c4', '\U0001d7cb'), ('\U0001ee00', '\U0001ee03'),
- ('\U0001ee05', '\U0001ee1f'), ('\U0001ee21', '\U0001ee22'),
- ('\U0001ee24', '\U0001ee24'), ('\U0001ee27', '\U0001ee27'),
- ('\U0001ee29', '\U0001ee32'), ('\U0001ee34', '\U0001ee37'),
- ('\U0001ee39', '\U0001ee39'), ('\U0001ee3b', '\U0001ee3b'),
- ('\U0001ee42', '\U0001ee42'), ('\U0001ee47', '\U0001ee47'),
- ('\U0001ee49', '\U0001ee49'), ('\U0001ee4b', '\U0001ee4b'),
- ('\U0001ee4d', '\U0001ee4f'), ('\U0001ee51', '\U0001ee52'),
- ('\U0001ee54', '\U0001ee54'), ('\U0001ee57', '\U0001ee57'),
- ('\U0001ee59', '\U0001ee59'), ('\U0001ee5b', '\U0001ee5b'),
- ('\U0001ee5d', '\U0001ee5d'), ('\U0001ee5f', '\U0001ee5f'),
- ('\U0001ee61', '\U0001ee62'), ('\U0001ee64', '\U0001ee64'),
- ('\U0001ee67', '\U0001ee6a'), ('\U0001ee6c', '\U0001ee72'),
- ('\U0001ee74', '\U0001ee77'), ('\U0001ee79', '\U0001ee7c'),
- ('\U0001ee7e', '\U0001ee7e'), ('\U0001ee80', '\U0001ee89'),
- ('\U0001ee8b', '\U0001ee9b'), ('\U0001eea1', '\U0001eea3'),
- ('\U0001eea5', '\U0001eea9'), ('\U0001eeab', '\U0001eebb'),
- ('\U00020000', '\U0002a6d6'), ('\U0002a700', '\U0002b734'),
- ('\U0002b740', '\U0002b81d'), ('\U0002f800', '\U0002fa1d')
- ];
-
- pub fn Alphabetic(c: char) -> bool {
- super::bsearch_range_table(c, Alphabetic_table)
- }
-
- static Lowercase_table : &'static [(char,char)] = &[
- ('\x61', '\x7a'), ('\xaa', '\xaa'),
- ('\xb5', '\xb5'), ('\xba', '\xba'),
- ('\xdf', '\xf6'), ('\xf8', '\xff'),
- ('\u0101', '\u0101'), ('\u0103', '\u0103'),
- ('\u0105', '\u0105'), ('\u0107', '\u0107'),
- ('\u0109', '\u0109'), ('\u010b', '\u010b'),
- ('\u010d', '\u010d'), ('\u010f', '\u010f'),
- ('\u0111', '\u0111'), ('\u0113', '\u0113'),
- ('\u0115', '\u0115'), ('\u0117', '\u0117'),
- ('\u0119', '\u0119'), ('\u011b', '\u011b'),
- ('\u011d', '\u011d'), ('\u011f', '\u011f'),
- ('\u0121', '\u0121'), ('\u0123', '\u0123'),
- ('\u0125', '\u0125'), ('\u0127', '\u0127'),
- ('\u0129', '\u0129'), ('\u012b', '\u012b'),
- ('\u012d', '\u012d'), ('\u012f', '\u012f'),
- ('\u0131', '\u0131'), ('\u0133', '\u0133'),
- ('\u0135', '\u0135'), ('\u0137', '\u0138'),
- ('\u013a', '\u013a'), ('\u013c', '\u013c'),
- ('\u013e', '\u013e'), ('\u0140', '\u0140'),
- ('\u0142', '\u0142'), ('\u0144', '\u0144'),
- ('\u0146', '\u0146'), ('\u0148', '\u0149'),
- ('\u014b', '\u014b'), ('\u014d', '\u014d'),
- ('\u014f', '\u014f'), ('\u0151', '\u0151'),
- ('\u0153', '\u0153'), ('\u0155', '\u0155'),
- ('\u0157', '\u0157'), ('\u0159', '\u0159'),
- ('\u015b', '\u015b'), ('\u015d', '\u015d'),
- ('\u015f', '\u015f'), ('\u0161', '\u0161'),
- ('\u0163', '\u0163'), ('\u0165', '\u0165'),
- ('\u0167', '\u0167'), ('\u0169', '\u0169'),
- ('\u016b', '\u016b'), ('\u016d', '\u016d'),
- ('\u016f', '\u016f'), ('\u0171', '\u0171'),
- ('\u0173', '\u0173'), ('\u0175', '\u0175'),
- ('\u0177', '\u0177'), ('\u017a', '\u017a'),
- ('\u017c', '\u017c'), ('\u017e', '\u0180'),
- ('\u0183', '\u0183'), ('\u0185', '\u0185'),
- ('\u0188', '\u0188'), ('\u018c', '\u018d'),
- ('\u0192', '\u0192'), ('\u0195', '\u0195'),
- ('\u0199', '\u019b'), ('\u019e', '\u019e'),
- ('\u01a1', '\u01a1'), ('\u01a3', '\u01a3'),
- ('\u01a5', '\u01a5'), ('\u01a8', '\u01a8'),
- ('\u01aa', '\u01ab'), ('\u01ad', '\u01ad'),
- ('\u01b0', '\u01b0'), ('\u01b4', '\u01b4'),
- ('\u01b6', '\u01b6'), ('\u01b9', '\u01ba'),
- ('\u01bd', '\u01bf'), ('\u01c6', '\u01c6'),
- ('\u01c9', '\u01c9'), ('\u01cc', '\u01cc'),
- ('\u01ce', '\u01ce'), ('\u01d0', '\u01d0'),
- ('\u01d2', '\u01d2'), ('\u01d4', '\u01d4'),
- ('\u01d6', '\u01d6'), ('\u01d8', '\u01d8'),
- ('\u01da', '\u01da'), ('\u01dc', '\u01dd'),
- ('\u01df', '\u01df'), ('\u01e1', '\u01e1'),
- ('\u01e3', '\u01e3'), ('\u01e5', '\u01e5'),
- ('\u01e7', '\u01e7'), ('\u01e9', '\u01e9'),
- ('\u01eb', '\u01eb'), ('\u01ed', '\u01ed'),
- ('\u01ef', '\u01f0'), ('\u01f3', '\u01f3'),
- ('\u01f5', '\u01f5'), ('\u01f9', '\u01f9'),
- ('\u01fb', '\u01fb'), ('\u01fd', '\u01fd'),
- ('\u01ff', '\u01ff'), ('\u0201', '\u0201'),
- ('\u0203', '\u0203'), ('\u0205', '\u0205'),
- ('\u0207', '\u0207'), ('\u0209', '\u0209'),
- ('\u020b', '\u020b'), ('\u020d', '\u020d'),
- ('\u020f', '\u020f'), ('\u0211', '\u0211'),
- ('\u0213', '\u0213'), ('\u0215', '\u0215'),
- ('\u0217', '\u0217'), ('\u0219', '\u0219'),
- ('\u021b', '\u021b'), ('\u021d', '\u021d'),
- ('\u021f', '\u021f'), ('\u0221', '\u0221'),
- ('\u0223', '\u0223'), ('\u0225', '\u0225'),
- ('\u0227', '\u0227'), ('\u0229', '\u0229'),
- ('\u022b', '\u022b'), ('\u022d', '\u022d'),
- ('\u022f', '\u022f'), ('\u0231', '\u0231'),
- ('\u0233', '\u0239'), ('\u023c', '\u023c'),
- ('\u023f', '\u0240'), ('\u0242', '\u0242'),
- ('\u0247', '\u0247'), ('\u0249', '\u0249'),
- ('\u024b', '\u024b'), ('\u024d', '\u024d'),
- ('\u024f', '\u0293'), ('\u0295', '\u02af'),
- ('\u02b0', '\u02b8'), ('\u02c0', '\u02c1'),
- ('\u02e0', '\u02e4'), ('\u0345', '\u0345'),
- ('\u0371', '\u0371'), ('\u0373', '\u0373'),
- ('\u0377', '\u0377'), ('\u037a', '\u037a'),
- ('\u037b', '\u037d'), ('\u0390', '\u0390'),
- ('\u03ac', '\u03ce'), ('\u03d0', '\u03d1'),
- ('\u03d5', '\u03d7'), ('\u03d9', '\u03d9'),
- ('\u03db', '\u03db'), ('\u03dd', '\u03dd'),
- ('\u03df', '\u03df'), ('\u03e1', '\u03e1'),
- ('\u03e3', '\u03e3'), ('\u03e5', '\u03e5'),
- ('\u03e7', '\u03e7'), ('\u03e9', '\u03e9'),
- ('\u03eb', '\u03eb'), ('\u03ed', '\u03ed'),
- ('\u03ef', '\u03f3'), ('\u03f5', '\u03f5'),
- ('\u03f8', '\u03f8'), ('\u03fb', '\u03fc'),
- ('\u0430', '\u045f'), ('\u0461', '\u0461'),
- ('\u0463', '\u0463'), ('\u0465', '\u0465'),
- ('\u0467', '\u0467'), ('\u0469', '\u0469'),
- ('\u046b', '\u046b'), ('\u046d', '\u046d'),
- ('\u046f', '\u046f'), ('\u0471', '\u0471'),
- ('\u0473', '\u0473'), ('\u0475', '\u0475'),
- ('\u0477', '\u0477'), ('\u0479', '\u0479'),
- ('\u047b', '\u047b'), ('\u047d', '\u047d'),
- ('\u047f', '\u047f'), ('\u0481', '\u0481'),
- ('\u048b', '\u048b'), ('\u048d', '\u048d'),
- ('\u048f', '\u048f'), ('\u0491', '\u0491'),
- ('\u0493', '\u0493'), ('\u0495', '\u0495'),
- ('\u0497', '\u0497'), ('\u0499', '\u0499'),
- ('\u049b', '\u049b'), ('\u049d', '\u049d'),
- ('\u049f', '\u049f'), ('\u04a1', '\u04a1'),
- ('\u04a3', '\u04a3'), ('\u04a5', '\u04a5'),
- ('\u04a7', '\u04a7'), ('\u04a9', '\u04a9'),
- ('\u04ab', '\u04ab'), ('\u04ad', '\u04ad'),
- ('\u04af', '\u04af'), ('\u04b1', '\u04b1'),
- ('\u04b3', '\u04b3'), ('\u04b5', '\u04b5'),
- ('\u04b7', '\u04b7'), ('\u04b9', '\u04b9'),
- ('\u04bb', '\u04bb'), ('\u04bd', '\u04bd'),
- ('\u04bf', '\u04bf'), ('\u04c2', '\u04c2'),
- ('\u04c4', '\u04c4'), ('\u04c6', '\u04c6'),
- ('\u04c8', '\u04c8'), ('\u04ca', '\u04ca'),
- ('\u04cc', '\u04cc'), ('\u04ce', '\u04cf'),
- ('\u04d1', '\u04d1'), ('\u04d3', '\u04d3'),
- ('\u04d5', '\u04d5'), ('\u04d7', '\u04d7'),
- ('\u04d9', '\u04d9'), ('\u04db', '\u04db'),
- ('\u04dd', '\u04dd'), ('\u04df', '\u04df'),
- ('\u04e1', '\u04e1'), ('\u04e3', '\u04e3'),
- ('\u04e5', '\u04e5'), ('\u04e7', '\u04e7'),
- ('\u04e9', '\u04e9'), ('\u04eb', '\u04eb'),
- ('\u04ed', '\u04ed'), ('\u04ef', '\u04ef'),
- ('\u04f1', '\u04f1'), ('\u04f3', '\u04f3'),
- ('\u04f5', '\u04f5'), ('\u04f7', '\u04f7'),
- ('\u04f9', '\u04f9'), ('\u04fb', '\u04fb'),
- ('\u04fd', '\u04fd'), ('\u04ff', '\u04ff'),
- ('\u0501', '\u0501'), ('\u0503', '\u0503'),
- ('\u0505', '\u0505'), ('\u0507', '\u0507'),
- ('\u0509', '\u0509'), ('\u050b', '\u050b'),
- ('\u050d', '\u050d'), ('\u050f', '\u050f'),
- ('\u0511', '\u0511'), ('\u0513', '\u0513'),
- ('\u0515', '\u0515'), ('\u0517', '\u0517'),
- ('\u0519', '\u0519'), ('\u051b', '\u051b'),
- ('\u051d', '\u051d'), ('\u051f', '\u051f'),
- ('\u0521', '\u0521'), ('\u0523', '\u0523'),
- ('\u0525', '\u0525'), ('\u0527', '\u0527'),
- ('\u0561', '\u0587'), ('\u1d00', '\u1d2b'),
- ('\u1d2c', '\u1d6a'), ('\u1d6b', '\u1d77'),
- ('\u1d78', '\u1d78'), ('\u1d79', '\u1d9a'),
- ('\u1d9b', '\u1dbf'), ('\u1e01', '\u1e01'),
- ('\u1e03', '\u1e03'), ('\u1e05', '\u1e05'),
- ('\u1e07', '\u1e07'), ('\u1e09', '\u1e09'),
- ('\u1e0b', '\u1e0b'), ('\u1e0d', '\u1e0d'),
- ('\u1e0f', '\u1e0f'), ('\u1e11', '\u1e11'),
- ('\u1e13', '\u1e13'), ('\u1e15', '\u1e15'),
- ('\u1e17', '\u1e17'), ('\u1e19', '\u1e19'),
- ('\u1e1b', '\u1e1b'), ('\u1e1d', '\u1e1d'),
- ('\u1e1f', '\u1e1f'), ('\u1e21', '\u1e21'),
- ('\u1e23', '\u1e23'), ('\u1e25', '\u1e25'),
- ('\u1e27', '\u1e27'), ('\u1e29', '\u1e29'),
- ('\u1e2b', '\u1e2b'), ('\u1e2d', '\u1e2d'),
- ('\u1e2f', '\u1e2f'), ('\u1e31', '\u1e31'),
- ('\u1e33', '\u1e33'), ('\u1e35', '\u1e35'),
- ('\u1e37', '\u1e37'), ('\u1e39', '\u1e39'),
- ('\u1e3b', '\u1e3b'), ('\u1e3d', '\u1e3d'),
- ('\u1e3f', '\u1e3f'), ('\u1e41', '\u1e41'),
- ('\u1e43', '\u1e43'), ('\u1e45', '\u1e45'),
- ('\u1e47', '\u1e47'), ('\u1e49', '\u1e49'),
- ('\u1e4b', '\u1e4b'), ('\u1e4d', '\u1e4d'),
- ('\u1e4f', '\u1e4f'), ('\u1e51', '\u1e51'),
- ('\u1e53', '\u1e53'), ('\u1e55', '\u1e55'),
- ('\u1e57', '\u1e57'), ('\u1e59', '\u1e59'),
- ('\u1e5b', '\u1e5b'), ('\u1e5d', '\u1e5d'),
- ('\u1e5f', '\u1e5f'), ('\u1e61', '\u1e61'),
- ('\u1e63', '\u1e63'), ('\u1e65', '\u1e65'),
- ('\u1e67', '\u1e67'), ('\u1e69', '\u1e69'),
- ('\u1e6b', '\u1e6b'), ('\u1e6d', '\u1e6d'),
- ('\u1e6f', '\u1e6f'), ('\u1e71', '\u1e71'),
- ('\u1e73', '\u1e73'), ('\u1e75', '\u1e75'),
- ('\u1e77', '\u1e77'), ('\u1e79', '\u1e79'),
- ('\u1e7b', '\u1e7b'), ('\u1e7d', '\u1e7d'),
- ('\u1e7f', '\u1e7f'), ('\u1e81', '\u1e81'),
- ('\u1e83', '\u1e83'), ('\u1e85', '\u1e85'),
- ('\u1e87', '\u1e87'), ('\u1e89', '\u1e89'),
- ('\u1e8b', '\u1e8b'), ('\u1e8d', '\u1e8d'),
- ('\u1e8f', '\u1e8f'), ('\u1e91', '\u1e91'),
- ('\u1e93', '\u1e93'), ('\u1e95', '\u1e9d'),
- ('\u1e9f', '\u1e9f'), ('\u1ea1', '\u1ea1'),
- ('\u1ea3', '\u1ea3'), ('\u1ea5', '\u1ea5'),
- ('\u1ea7', '\u1ea7'), ('\u1ea9', '\u1ea9'),
- ('\u1eab', '\u1eab'), ('\u1ead', '\u1ead'),
- ('\u1eaf', '\u1eaf'), ('\u1eb1', '\u1eb1'),
- ('\u1eb3', '\u1eb3'), ('\u1eb5', '\u1eb5'),
- ('\u1eb7', '\u1eb7'), ('\u1eb9', '\u1eb9'),
- ('\u1ebb', '\u1ebb'), ('\u1ebd', '\u1ebd'),
- ('\u1ebf', '\u1ebf'), ('\u1ec1', '\u1ec1'),
- ('\u1ec3', '\u1ec3'), ('\u1ec5', '\u1ec5'),
- ('\u1ec7', '\u1ec7'), ('\u1ec9', '\u1ec9'),
- ('\u1ecb', '\u1ecb'), ('\u1ecd', '\u1ecd'),
- ('\u1ecf', '\u1ecf'), ('\u1ed1', '\u1ed1'),
- ('\u1ed3', '\u1ed3'), ('\u1ed5', '\u1ed5'),
- ('\u1ed7', '\u1ed7'), ('\u1ed9', '\u1ed9'),
- ('\u1edb', '\u1edb'), ('\u1edd', '\u1edd'),
- ('\u1edf', '\u1edf'), ('\u1ee1', '\u1ee1'),
- ('\u1ee3', '\u1ee3'), ('\u1ee5', '\u1ee5'),
- ('\u1ee7', '\u1ee7'), ('\u1ee9', '\u1ee9'),
- ('\u1eeb', '\u1eeb'), ('\u1eed', '\u1eed'),
- ('\u1eef', '\u1eef'), ('\u1ef1', '\u1ef1'),
- ('\u1ef3', '\u1ef3'), ('\u1ef5', '\u1ef5'),
- ('\u1ef7', '\u1ef7'), ('\u1ef9', '\u1ef9'),
- ('\u1efb', '\u1efb'), ('\u1efd', '\u1efd'),
- ('\u1eff', '\u1f07'), ('\u1f10', '\u1f15'),
- ('\u1f20', '\u1f27'), ('\u1f30', '\u1f37'),
- ('\u1f40', '\u1f45'), ('\u1f50', '\u1f57'),
- ('\u1f60', '\u1f67'), ('\u1f70', '\u1f7d'),
- ('\u1f80', '\u1f87'), ('\u1f90', '\u1f97'),
- ('\u1fa0', '\u1fa7'), ('\u1fb0', '\u1fb4'),
- ('\u1fb6', '\u1fb7'), ('\u1fbe', '\u1fbe'),
- ('\u1fc2', '\u1fc4'), ('\u1fc6', '\u1fc7'),
- ('\u1fd0', '\u1fd3'), ('\u1fd6', '\u1fd7'),
- ('\u1fe0', '\u1fe7'), ('\u1ff2', '\u1ff4'),
- ('\u1ff6', '\u1ff7'), ('\u2071', '\u2071'),
- ('\u207f', '\u207f'), ('\u2090', '\u209c'),
- ('\u210a', '\u210a'), ('\u210e', '\u210f'),
- ('\u2113', '\u2113'), ('\u212f', '\u212f'),
- ('\u2134', '\u2134'), ('\u2139', '\u2139'),
- ('\u213c', '\u213d'), ('\u2146', '\u2149'),
- ('\u214e', '\u214e'), ('\u2170', '\u217f'),
- ('\u2184', '\u2184'), ('\u24d0', '\u24e9'),
- ('\u2c30', '\u2c5e'), ('\u2c61', '\u2c61'),
- ('\u2c65', '\u2c66'), ('\u2c68', '\u2c68'),
- ('\u2c6a', '\u2c6a'), ('\u2c6c', '\u2c6c'),
- ('\u2c71', '\u2c71'), ('\u2c73', '\u2c74'),
- ('\u2c76', '\u2c7b'), ('\u2c7c', '\u2c7d'),
- ('\u2c81', '\u2c81'), ('\u2c83', '\u2c83'),
- ('\u2c85', '\u2c85'), ('\u2c87', '\u2c87'),
- ('\u2c89', '\u2c89'), ('\u2c8b', '\u2c8b'),
- ('\u2c8d', '\u2c8d'), ('\u2c8f', '\u2c8f'),
- ('\u2c91', '\u2c91'), ('\u2c93', '\u2c93'),
- ('\u2c95', '\u2c95'), ('\u2c97', '\u2c97'),
- ('\u2c99', '\u2c99'), ('\u2c9b', '\u2c9b'),
- ('\u2c9d', '\u2c9d'), ('\u2c9f', '\u2c9f'),
- ('\u2ca1', '\u2ca1'), ('\u2ca3', '\u2ca3'),
- ('\u2ca5', '\u2ca5'), ('\u2ca7', '\u2ca7'),
- ('\u2ca9', '\u2ca9'), ('\u2cab', '\u2cab'),
- ('\u2cad', '\u2cad'), ('\u2caf', '\u2caf'),
- ('\u2cb1', '\u2cb1'), ('\u2cb3', '\u2cb3'),
- ('\u2cb5', '\u2cb5'), ('\u2cb7', '\u2cb7'),
- ('\u2cb9', '\u2cb9'), ('\u2cbb', '\u2cbb'),
- ('\u2cbd', '\u2cbd'), ('\u2cbf', '\u2cbf'),
- ('\u2cc1', '\u2cc1'), ('\u2cc3', '\u2cc3'),
- ('\u2cc5', '\u2cc5'), ('\u2cc7', '\u2cc7'),
- ('\u2cc9', '\u2cc9'), ('\u2ccb', '\u2ccb'),
- ('\u2ccd', '\u2ccd'), ('\u2ccf', '\u2ccf'),
- ('\u2cd1', '\u2cd1'), ('\u2cd3', '\u2cd3'),
- ('\u2cd5', '\u2cd5'), ('\u2cd7', '\u2cd7'),
- ('\u2cd9', '\u2cd9'), ('\u2cdb', '\u2cdb'),
- ('\u2cdd', '\u2cdd'), ('\u2cdf', '\u2cdf'),
- ('\u2ce1', '\u2ce1'), ('\u2ce3', '\u2ce4'),
- ('\u2cec', '\u2cec'), ('\u2cee', '\u2cee'),
- ('\u2cf3', '\u2cf3'), ('\u2d00', '\u2d25'),
- ('\u2d27', '\u2d27'), ('\u2d2d', '\u2d2d'),
- ('\ua641', '\ua641'), ('\ua643', '\ua643'),
- ('\ua645', '\ua645'), ('\ua647', '\ua647'),
- ('\ua649', '\ua649'), ('\ua64b', '\ua64b'),
- ('\ua64d', '\ua64d'), ('\ua64f', '\ua64f'),
- ('\ua651', '\ua651'), ('\ua653', '\ua653'),
- ('\ua655', '\ua655'), ('\ua657', '\ua657'),
- ('\ua659', '\ua659'), ('\ua65b', '\ua65b'),
- ('\ua65d', '\ua65d'), ('\ua65f', '\ua65f'),
- ('\ua661', '\ua661'), ('\ua663', '\ua663'),
- ('\ua665', '\ua665'), ('\ua667', '\ua667'),
- ('\ua669', '\ua669'), ('\ua66b', '\ua66b'),
- ('\ua66d', '\ua66d'), ('\ua681', '\ua681'),
- ('\ua683', '\ua683'), ('\ua685', '\ua685'),
- ('\ua687', '\ua687'), ('\ua689', '\ua689'),
- ('\ua68b', '\ua68b'), ('\ua68d', '\ua68d'),
- ('\ua68f', '\ua68f'), ('\ua691', '\ua691'),
- ('\ua693', '\ua693'), ('\ua695', '\ua695'),
- ('\ua697', '\ua697'), ('\ua723', '\ua723'),
- ('\ua725', '\ua725'), ('\ua727', '\ua727'),
- ('\ua729', '\ua729'), ('\ua72b', '\ua72b'),
- ('\ua72d', '\ua72d'), ('\ua72f', '\ua731'),
- ('\ua733', '\ua733'), ('\ua735', '\ua735'),
- ('\ua737', '\ua737'), ('\ua739', '\ua739'),
- ('\ua73b', '\ua73b'), ('\ua73d', '\ua73d'),
- ('\ua73f', '\ua73f'), ('\ua741', '\ua741'),
- ('\ua743', '\ua743'), ('\ua745', '\ua745'),
- ('\ua747', '\ua747'), ('\ua749', '\ua749'),
- ('\ua74b', '\ua74b'), ('\ua74d', '\ua74d'),
- ('\ua74f', '\ua74f'), ('\ua751', '\ua751'),
- ('\ua753', '\ua753'), ('\ua755', '\ua755'),
- ('\ua757', '\ua757'), ('\ua759', '\ua759'),
- ('\ua75b', '\ua75b'), ('\ua75d', '\ua75d'),
- ('\ua75f', '\ua75f'), ('\ua761', '\ua761'),
- ('\ua763', '\ua763'), ('\ua765', '\ua765'),
- ('\ua767', '\ua767'), ('\ua769', '\ua769'),
- ('\ua76b', '\ua76b'), ('\ua76d', '\ua76d'),
- ('\ua76f', '\ua76f'), ('\ua770', '\ua770'),
- ('\ua771', '\ua778'), ('\ua77a', '\ua77a'),
- ('\ua77c', '\ua77c'), ('\ua77f', '\ua77f'),
- ('\ua781', '\ua781'), ('\ua783', '\ua783'),
- ('\ua785', '\ua785'), ('\ua787', '\ua787'),
- ('\ua78c', '\ua78c'), ('\ua78e', '\ua78e'),
- ('\ua791', '\ua791'), ('\ua793', '\ua793'),
- ('\ua7a1', '\ua7a1'), ('\ua7a3', '\ua7a3'),
- ('\ua7a5', '\ua7a5'), ('\ua7a7', '\ua7a7'),
- ('\ua7a9', '\ua7a9'), ('\ua7f8', '\ua7f9'),
- ('\ua7fa', '\ua7fa'), ('\ufb00', '\ufb06'),
- ('\ufb13', '\ufb17'), ('\uff41', '\uff5a'),
- ('\U00010428', '\U0001044f'), ('\U0001d41a', '\U0001d433'),
- ('\U0001d44e', '\U0001d454'), ('\U0001d456', '\U0001d467'),
- ('\U0001d482', '\U0001d49b'), ('\U0001d4b6', '\U0001d4b9'),
- ('\U0001d4bb', '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'),
- ('\U0001d4c5', '\U0001d4cf'), ('\U0001d4ea', '\U0001d503'),
- ('\U0001d51e', '\U0001d537'), ('\U0001d552', '\U0001d56b'),
- ('\U0001d586', '\U0001d59f'), ('\U0001d5ba', '\U0001d5d3'),
- ('\U0001d5ee', '\U0001d607'), ('\U0001d622', '\U0001d63b'),
- ('\U0001d656', '\U0001d66f'), ('\U0001d68a', '\U0001d6a5'),
- ('\U0001d6c2', '\U0001d6da'), ('\U0001d6dc', '\U0001d6e1'),
- ('\U0001d6fc', '\U0001d714'), ('\U0001d716', '\U0001d71b'),
- ('\U0001d736', '\U0001d74e'), ('\U0001d750', '\U0001d755'),
- ('\U0001d770', '\U0001d788'), ('\U0001d78a', '\U0001d78f'),
- ('\U0001d7aa', '\U0001d7c2'), ('\U0001d7c4', '\U0001d7c9'),
- ('\U0001d7cb', '\U0001d7cb')
- ];
-
- pub fn Lowercase(c: char) -> bool {
- super::bsearch_range_table(c, Lowercase_table)
- }
-
- static Uppercase_table : &'static [(char,char)] = &[
- ('\x41', '\x5a'), ('\xc0', '\xd6'),
- ('\xd8', '\xde'), ('\u0100', '\u0100'),
- ('\u0102', '\u0102'), ('\u0104', '\u0104'),
- ('\u0106', '\u0106'), ('\u0108', '\u0108'),
- ('\u010a', '\u010a'), ('\u010c', '\u010c'),
- ('\u010e', '\u010e'), ('\u0110', '\u0110'),
- ('\u0112', '\u0112'), ('\u0114', '\u0114'),
- ('\u0116', '\u0116'), ('\u0118', '\u0118'),
- ('\u011a', '\u011a'), ('\u011c', '\u011c'),
- ('\u011e', '\u011e'), ('\u0120', '\u0120'),
- ('\u0122', '\u0122'), ('\u0124', '\u0124'),
- ('\u0126', '\u0126'), ('\u0128', '\u0128'),
- ('\u012a', '\u012a'), ('\u012c', '\u012c'),
- ('\u012e', '\u012e'), ('\u0130', '\u0130'),
- ('\u0132', '\u0132'), ('\u0134', '\u0134'),
- ('\u0136', '\u0136'), ('\u0139', '\u0139'),
- ('\u013b', '\u013b'), ('\u013d', '\u013d'),
- ('\u013f', '\u013f'), ('\u0141', '\u0141'),
- ('\u0143', '\u0143'), ('\u0145', '\u0145'),
- ('\u0147', '\u0147'), ('\u014a', '\u014a'),
- ('\u014c', '\u014c'), ('\u014e', '\u014e'),
- ('\u0150', '\u0150'), ('\u0152', '\u0152'),
- ('\u0154', '\u0154'), ('\u0156', '\u0156'),
- ('\u0158', '\u0158'), ('\u015a', '\u015a'),
- ('\u015c', '\u015c'), ('\u015e', '\u015e'),
- ('\u0160', '\u0160'), ('\u0162', '\u0162'),
- ('\u0164', '\u0164'), ('\u0166', '\u0166'),
- ('\u0168', '\u0168'), ('\u016a', '\u016a'),
- ('\u016c', '\u016c'), ('\u016e', '\u016e'),
- ('\u0170', '\u0170'), ('\u0172', '\u0172'),
- ('\u0174', '\u0174'), ('\u0176', '\u0176'),
- ('\u0178', '\u0179'), ('\u017b', '\u017b'),
- ('\u017d', '\u017d'), ('\u0181', '\u0182'),
- ('\u0184', '\u0184'), ('\u0186', '\u0187'),
- ('\u0189', '\u018b'), ('\u018e', '\u0191'),
- ('\u0193', '\u0194'), ('\u0196', '\u0198'),
- ('\u019c', '\u019d'), ('\u019f', '\u01a0'),
- ('\u01a2', '\u01a2'), ('\u01a4', '\u01a4'),
- ('\u01a6', '\u01a7'), ('\u01a9', '\u01a9'),
- ('\u01ac', '\u01ac'), ('\u01ae', '\u01af'),
- ('\u01b1', '\u01b3'), ('\u01b5', '\u01b5'),
- ('\u01b7', '\u01b8'), ('\u01bc', '\u01bc'),
- ('\u01c4', '\u01c4'), ('\u01c7', '\u01c7'),
- ('\u01ca', '\u01ca'), ('\u01cd', '\u01cd'),
- ('\u01cf', '\u01cf'), ('\u01d1', '\u01d1'),
- ('\u01d3', '\u01d3'), ('\u01d5', '\u01d5'),
- ('\u01d7', '\u01d7'), ('\u01d9', '\u01d9'),
- ('\u01db', '\u01db'), ('\u01de', '\u01de'),
- ('\u01e0', '\u01e0'), ('\u01e2', '\u01e2'),
- ('\u01e4', '\u01e4'), ('\u01e6', '\u01e6'),
- ('\u01e8', '\u01e8'), ('\u01ea', '\u01ea'),
- ('\u01ec', '\u01ec'), ('\u01ee', '\u01ee'),
- ('\u01f1', '\u01f1'), ('\u01f4', '\u01f4'),
- ('\u01f6', '\u01f8'), ('\u01fa', '\u01fa'),
- ('\u01fc', '\u01fc'), ('\u01fe', '\u01fe'),
- ('\u0200', '\u0200'), ('\u0202', '\u0202'),
- ('\u0204', '\u0204'), ('\u0206', '\u0206'),
- ('\u0208', '\u0208'), ('\u020a', '\u020a'),
- ('\u020c', '\u020c'), ('\u020e', '\u020e'),
- ('\u0210', '\u0210'), ('\u0212', '\u0212'),
- ('\u0214', '\u0214'), ('\u0216', '\u0216'),
- ('\u0218', '\u0218'), ('\u021a', '\u021a'),
- ('\u021c', '\u021c'), ('\u021e', '\u021e'),
- ('\u0220', '\u0220'), ('\u0222', '\u0222'),
- ('\u0224', '\u0224'), ('\u0226', '\u0226'),
- ('\u0228', '\u0228'), ('\u022a', '\u022a'),
- ('\u022c', '\u022c'), ('\u022e', '\u022e'),
- ('\u0230', '\u0230'), ('\u0232', '\u0232'),
- ('\u023a', '\u023b'), ('\u023d', '\u023e'),
- ('\u0241', '\u0241'), ('\u0243', '\u0246'),
- ('\u0248', '\u0248'), ('\u024a', '\u024a'),
- ('\u024c', '\u024c'), ('\u024e', '\u024e'),
- ('\u0370', '\u0370'), ('\u0372', '\u0372'),
- ('\u0376', '\u0376'), ('\u0386', '\u0386'),
- ('\u0388', '\u038a'), ('\u038c', '\u038c'),
- ('\u038e', '\u038f'), ('\u0391', '\u03a1'),
- ('\u03a3', '\u03ab'), ('\u03cf', '\u03cf'),
- ('\u03d2', '\u03d4'), ('\u03d8', '\u03d8'),
- ('\u03da', '\u03da'), ('\u03dc', '\u03dc'),
- ('\u03de', '\u03de'), ('\u03e0', '\u03e0'),
- ('\u03e2', '\u03e2'), ('\u03e4', '\u03e4'),
- ('\u03e6', '\u03e6'), ('\u03e8', '\u03e8'),
- ('\u03ea', '\u03ea'), ('\u03ec', '\u03ec'),
- ('\u03ee', '\u03ee'), ('\u03f4', '\u03f4'),
- ('\u03f7', '\u03f7'), ('\u03f9', '\u03fa'),
- ('\u03fd', '\u042f'), ('\u0460', '\u0460'),
- ('\u0462', '\u0462'), ('\u0464', '\u0464'),
- ('\u0466', '\u0466'), ('\u0468', '\u0468'),
- ('\u046a', '\u046a'), ('\u046c', '\u046c'),
- ('\u046e', '\u046e'), ('\u0470', '\u0470'),
- ('\u0472', '\u0472'), ('\u0474', '\u0474'),
- ('\u0476', '\u0476'), ('\u0478', '\u0478'),
- ('\u047a', '\u047a'), ('\u047c', '\u047c'),
- ('\u047e', '\u047e'), ('\u0480', '\u0480'),
- ('\u048a', '\u048a'), ('\u048c', '\u048c'),
- ('\u048e', '\u048e'), ('\u0490', '\u0490'),
- ('\u0492', '\u0492'), ('\u0494', '\u0494'),
- ('\u0496', '\u0496'), ('\u0498', '\u0498'),
- ('\u049a', '\u049a'), ('\u049c', '\u049c'),
- ('\u049e', '\u049e'), ('\u04a0', '\u04a0'),
- ('\u04a2', '\u04a2'), ('\u04a4', '\u04a4'),
- ('\u04a6', '\u04a6'), ('\u04a8', '\u04a8'),
- ('\u04aa', '\u04aa'), ('\u04ac', '\u04ac'),
- ('\u04ae', '\u04ae'), ('\u04b0', '\u04b0'),
- ('\u04b2', '\u04b2'), ('\u04b4', '\u04b4'),
- ('\u04b6', '\u04b6'), ('\u04b8', '\u04b8'),
- ('\u04ba', '\u04ba'), ('\u04bc', '\u04bc'),
- ('\u04be', '\u04be'), ('\u04c0', '\u04c1'),
- ('\u04c3', '\u04c3'), ('\u04c5', '\u04c5'),
- ('\u04c7', '\u04c7'), ('\u04c9', '\u04c9'),
- ('\u04cb', '\u04cb'), ('\u04cd', '\u04cd'),
- ('\u04d0', '\u04d0'), ('\u04d2', '\u04d2'),
- ('\u04d4', '\u04d4'), ('\u04d6', '\u04d6'),
- ('\u04d8', '\u04d8'), ('\u04da', '\u04da'),
- ('\u04dc', '\u04dc'), ('\u04de', '\u04de'),
- ('\u04e0', '\u04e0'), ('\u04e2', '\u04e2'),
- ('\u04e4', '\u04e4'), ('\u04e6', '\u04e6'),
- ('\u04e8', '\u04e8'), ('\u04ea', '\u04ea'),
- ('\u04ec', '\u04ec'), ('\u04ee', '\u04ee'),
- ('\u04f0', '\u04f0'), ('\u04f2', '\u04f2'),
- ('\u04f4', '\u04f4'), ('\u04f6', '\u04f6'),
- ('\u04f8', '\u04f8'), ('\u04fa', '\u04fa'),
- ('\u04fc', '\u04fc'), ('\u04fe', '\u04fe'),
- ('\u0500', '\u0500'), ('\u0502', '\u0502'),
- ('\u0504', '\u0504'), ('\u0506', '\u0506'),
- ('\u0508', '\u0508'), ('\u050a', '\u050a'),
- ('\u050c', '\u050c'), ('\u050e', '\u050e'),
- ('\u0510', '\u0510'), ('\u0512', '\u0512'),
- ('\u0514', '\u0514'), ('\u0516', '\u0516'),
- ('\u0518', '\u0518'), ('\u051a', '\u051a'),
- ('\u051c', '\u051c'), ('\u051e', '\u051e'),
- ('\u0520', '\u0520'), ('\u0522', '\u0522'),
- ('\u0524', '\u0524'), ('\u0526', '\u0526'),
- ('\u0531', '\u0556'), ('\u10a0', '\u10c5'),
- ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'),
- ('\u1e00', '\u1e00'), ('\u1e02', '\u1e02'),
- ('\u1e04', '\u1e04'), ('\u1e06', '\u1e06'),
- ('\u1e08', '\u1e08'), ('\u1e0a', '\u1e0a'),
- ('\u1e0c', '\u1e0c'), ('\u1e0e', '\u1e0e'),
- ('\u1e10', '\u1e10'), ('\u1e12', '\u1e12'),
- ('\u1e14', '\u1e14'), ('\u1e16', '\u1e16'),
- ('\u1e18', '\u1e18'), ('\u1e1a', '\u1e1a'),
- ('\u1e1c', '\u1e1c'), ('\u1e1e', '\u1e1e'),
- ('\u1e20', '\u1e20'), ('\u1e22', '\u1e22'),
- ('\u1e24', '\u1e24'), ('\u1e26', '\u1e26'),
- ('\u1e28', '\u1e28'), ('\u1e2a', '\u1e2a'),
- ('\u1e2c', '\u1e2c'), ('\u1e2e', '\u1e2e'),
- ('\u1e30', '\u1e30'), ('\u1e32', '\u1e32'),
- ('\u1e34', '\u1e34'), ('\u1e36', '\u1e36'),
- ('\u1e38', '\u1e38'), ('\u1e3a', '\u1e3a'),
- ('\u1e3c', '\u1e3c'), ('\u1e3e', '\u1e3e'),
- ('\u1e40', '\u1e40'), ('\u1e42', '\u1e42'),
- ('\u1e44', '\u1e44'), ('\u1e46', '\u1e46'),
- ('\u1e48', '\u1e48'), ('\u1e4a', '\u1e4a'),
- ('\u1e4c', '\u1e4c'), ('\u1e4e', '\u1e4e'),
- ('\u1e50', '\u1e50'), ('\u1e52', '\u1e52'),
- ('\u1e54', '\u1e54'), ('\u1e56', '\u1e56'),
- ('\u1e58', '\u1e58'), ('\u1e5a', '\u1e5a'),
- ('\u1e5c', '\u1e5c'), ('\u1e5e', '\u1e5e'),
- ('\u1e60', '\u1e60'), ('\u1e62', '\u1e62'),
- ('\u1e64', '\u1e64'), ('\u1e66', '\u1e66'),
- ('\u1e68', '\u1e68'), ('\u1e6a', '\u1e6a'),
- ('\u1e6c', '\u1e6c'), ('\u1e6e', '\u1e6e'),
- ('\u1e70', '\u1e70'), ('\u1e72', '\u1e72'),
- ('\u1e74', '\u1e74'), ('\u1e76', '\u1e76'),
- ('\u1e78', '\u1e78'), ('\u1e7a', '\u1e7a'),
- ('\u1e7c', '\u1e7c'), ('\u1e7e', '\u1e7e'),
- ('\u1e80', '\u1e80'), ('\u1e82', '\u1e82'),
- ('\u1e84', '\u1e84'), ('\u1e86', '\u1e86'),
- ('\u1e88', '\u1e88'), ('\u1e8a', '\u1e8a'),
- ('\u1e8c', '\u1e8c'), ('\u1e8e', '\u1e8e'),
- ('\u1e90', '\u1e90'), ('\u1e92', '\u1e92'),
- ('\u1e94', '\u1e94'), ('\u1e9e', '\u1e9e'),
- ('\u1ea0', '\u1ea0'), ('\u1ea2', '\u1ea2'),
- ('\u1ea4', '\u1ea4'), ('\u1ea6', '\u1ea6'),
- ('\u1ea8', '\u1ea8'), ('\u1eaa', '\u1eaa'),
- ('\u1eac', '\u1eac'), ('\u1eae', '\u1eae'),
- ('\u1eb0', '\u1eb0'), ('\u1eb2', '\u1eb2'),
- ('\u1eb4', '\u1eb4'), ('\u1eb6', '\u1eb6'),
- ('\u1eb8', '\u1eb8'), ('\u1eba', '\u1eba'),
- ('\u1ebc', '\u1ebc'), ('\u1ebe', '\u1ebe'),
- ('\u1ec0', '\u1ec0'), ('\u1ec2', '\u1ec2'),
- ('\u1ec4', '\u1ec4'), ('\u1ec6', '\u1ec6'),
- ('\u1ec8', '\u1ec8'), ('\u1eca', '\u1eca'),
- ('\u1ecc', '\u1ecc'), ('\u1ece', '\u1ece'),
- ('\u1ed0', '\u1ed0'), ('\u1ed2', '\u1ed2'),
- ('\u1ed4', '\u1ed4'), ('\u1ed6', '\u1ed6'),
- ('\u1ed8', '\u1ed8'), ('\u1eda', '\u1eda'),
- ('\u1edc', '\u1edc'), ('\u1ede', '\u1ede'),
- ('\u1ee0', '\u1ee0'), ('\u1ee2', '\u1ee2'),
- ('\u1ee4', '\u1ee4'), ('\u1ee6', '\u1ee6'),
- ('\u1ee8', '\u1ee8'), ('\u1eea', '\u1eea'),
- ('\u1eec', '\u1eec'), ('\u1eee', '\u1eee'),
- ('\u1ef0', '\u1ef0'), ('\u1ef2', '\u1ef2'),
- ('\u1ef4', '\u1ef4'), ('\u1ef6', '\u1ef6'),
- ('\u1ef8', '\u1ef8'), ('\u1efa', '\u1efa'),
- ('\u1efc', '\u1efc'), ('\u1efe', '\u1efe'),
- ('\u1f08', '\u1f0f'), ('\u1f18', '\u1f1d'),
- ('\u1f28', '\u1f2f'), ('\u1f38', '\u1f3f'),
- ('\u1f48', '\u1f4d'), ('\u1f59', '\u1f59'),
- ('\u1f5b', '\u1f5b'), ('\u1f5d', '\u1f5d'),
- ('\u1f5f', '\u1f5f'), ('\u1f68', '\u1f6f'),
- ('\u1fb8', '\u1fbb'), ('\u1fc8', '\u1fcb'),
- ('\u1fd8', '\u1fdb'), ('\u1fe8', '\u1fec'),
- ('\u1ff8', '\u1ffb'), ('\u2102', '\u2102'),
- ('\u2107', '\u2107'), ('\u210b', '\u210d'),
- ('\u2110', '\u2112'), ('\u2115', '\u2115'),
- ('\u2119', '\u211d'), ('\u2124', '\u2124'),
- ('\u2126', '\u2126'), ('\u2128', '\u2128'),
- ('\u212a', '\u212d'), ('\u2130', '\u2133'),
- ('\u213e', '\u213f'), ('\u2145', '\u2145'),
- ('\u2160', '\u216f'), ('\u2183', '\u2183'),
- ('\u24b6', '\u24cf'), ('\u2c00', '\u2c2e'),
- ('\u2c60', '\u2c60'), ('\u2c62', '\u2c64'),
- ('\u2c67', '\u2c67'), ('\u2c69', '\u2c69'),
- ('\u2c6b', '\u2c6b'), ('\u2c6d', '\u2c70'),
- ('\u2c72', '\u2c72'), ('\u2c75', '\u2c75'),
- ('\u2c7e', '\u2c80'), ('\u2c82', '\u2c82'),
- ('\u2c84', '\u2c84'), ('\u2c86', '\u2c86'),
- ('\u2c88', '\u2c88'), ('\u2c8a', '\u2c8a'),
- ('\u2c8c', '\u2c8c'), ('\u2c8e', '\u2c8e'),
- ('\u2c90', '\u2c90'), ('\u2c92', '\u2c92'),
- ('\u2c94', '\u2c94'), ('\u2c96', '\u2c96'),
- ('\u2c98', '\u2c98'), ('\u2c9a', '\u2c9a'),
- ('\u2c9c', '\u2c9c'), ('\u2c9e', '\u2c9e'),
- ('\u2ca0', '\u2ca0'), ('\u2ca2', '\u2ca2'),
- ('\u2ca4', '\u2ca4'), ('\u2ca6', '\u2ca6'),
- ('\u2ca8', '\u2ca8'), ('\u2caa', '\u2caa'),
- ('\u2cac', '\u2cac'), ('\u2cae', '\u2cae'),
- ('\u2cb0', '\u2cb0'), ('\u2cb2', '\u2cb2'),
- ('\u2cb4', '\u2cb4'), ('\u2cb6', '\u2cb6'),
- ('\u2cb8', '\u2cb8'), ('\u2cba', '\u2cba'),
- ('\u2cbc', '\u2cbc'), ('\u2cbe', '\u2cbe'),
- ('\u2cc0', '\u2cc0'), ('\u2cc2', '\u2cc2'),
- ('\u2cc4', '\u2cc4'), ('\u2cc6', '\u2cc6'),
- ('\u2cc8', '\u2cc8'), ('\u2cca', '\u2cca'),
- ('\u2ccc', '\u2ccc'), ('\u2cce', '\u2cce'),
- ('\u2cd0', '\u2cd0'), ('\u2cd2', '\u2cd2'),
- ('\u2cd4', '\u2cd4'), ('\u2cd6', '\u2cd6'),
- ('\u2cd8', '\u2cd8'), ('\u2cda', '\u2cda'),
- ('\u2cdc', '\u2cdc'), ('\u2cde', '\u2cde'),
- ('\u2ce0', '\u2ce0'), ('\u2ce2', '\u2ce2'),
- ('\u2ceb', '\u2ceb'), ('\u2ced', '\u2ced'),
- ('\u2cf2', '\u2cf2'), ('\ua640', '\ua640'),
- ('\ua642', '\ua642'), ('\ua644', '\ua644'),
- ('\ua646', '\ua646'), ('\ua648', '\ua648'),
- ('\ua64a', '\ua64a'), ('\ua64c', '\ua64c'),
- ('\ua64e', '\ua64e'), ('\ua650', '\ua650'),
- ('\ua652', '\ua652'), ('\ua654', '\ua654'),
- ('\ua656', '\ua656'), ('\ua658', '\ua658'),
- ('\ua65a', '\ua65a'), ('\ua65c', '\ua65c'),
- ('\ua65e', '\ua65e'), ('\ua660', '\ua660'),
- ('\ua662', '\ua662'), ('\ua664', '\ua664'),
- ('\ua666', '\ua666'), ('\ua668', '\ua668'),
- ('\ua66a', '\ua66a'), ('\ua66c', '\ua66c'),
- ('\ua680', '\ua680'), ('\ua682', '\ua682'),
- ('\ua684', '\ua684'), ('\ua686', '\ua686'),
- ('\ua688', '\ua688'), ('\ua68a', '\ua68a'),
- ('\ua68c', '\ua68c'), ('\ua68e', '\ua68e'),
- ('\ua690', '\ua690'), ('\ua692', '\ua692'),
- ('\ua694', '\ua694'), ('\ua696', '\ua696'),
- ('\ua722', '\ua722'), ('\ua724', '\ua724'),
- ('\ua726', '\ua726'), ('\ua728', '\ua728'),
- ('\ua72a', '\ua72a'), ('\ua72c', '\ua72c'),
- ('\ua72e', '\ua72e'), ('\ua732', '\ua732'),
- ('\ua734', '\ua734'), ('\ua736', '\ua736'),
- ('\ua738', '\ua738'), ('\ua73a', '\ua73a'),
- ('\ua73c', '\ua73c'), ('\ua73e', '\ua73e'),
- ('\ua740', '\ua740'), ('\ua742', '\ua742'),
- ('\ua744', '\ua744'), ('\ua746', '\ua746'),
- ('\ua748', '\ua748'), ('\ua74a', '\ua74a'),
- ('\ua74c', '\ua74c'), ('\ua74e', '\ua74e'),
- ('\ua750', '\ua750'), ('\ua752', '\ua752'),
- ('\ua754', '\ua754'), ('\ua756', '\ua756'),
- ('\ua758', '\ua758'), ('\ua75a', '\ua75a'),
- ('\ua75c', '\ua75c'), ('\ua75e', '\ua75e'),
- ('\ua760', '\ua760'), ('\ua762', '\ua762'),
- ('\ua764', '\ua764'), ('\ua766', '\ua766'),
- ('\ua768', '\ua768'), ('\ua76a', '\ua76a'),
- ('\ua76c', '\ua76c'), ('\ua76e', '\ua76e'),
- ('\ua779', '\ua779'), ('\ua77b', '\ua77b'),
- ('\ua77d', '\ua77e'), ('\ua780', '\ua780'),
- ('\ua782', '\ua782'), ('\ua784', '\ua784'),
- ('\ua786', '\ua786'), ('\ua78b', '\ua78b'),
- ('\ua78d', '\ua78d'), ('\ua790', '\ua790'),
- ('\ua792', '\ua792'), ('\ua7a0', '\ua7a0'),
- ('\ua7a2', '\ua7a2'), ('\ua7a4', '\ua7a4'),
- ('\ua7a6', '\ua7a6'), ('\ua7a8', '\ua7a8'),
- ('\ua7aa', '\ua7aa'), ('\uff21', '\uff3a'),
- ('\U00010400', '\U00010427'), ('\U0001d400', '\U0001d419'),
- ('\U0001d434', '\U0001d44d'), ('\U0001d468', '\U0001d481'),
- ('\U0001d49c', '\U0001d49c'), ('\U0001d49e', '\U0001d49f'),
- ('\U0001d4a2', '\U0001d4a2'), ('\U0001d4a5', '\U0001d4a6'),
- ('\U0001d4a9', '\U0001d4ac'), ('\U0001d4ae', '\U0001d4b5'),
- ('\U0001d4d0', '\U0001d4e9'), ('\U0001d504', '\U0001d505'),
- ('\U0001d507', '\U0001d50a'), ('\U0001d50d', '\U0001d514'),
- ('\U0001d516', '\U0001d51c'), ('\U0001d538', '\U0001d539'),
- ('\U0001d53b', '\U0001d53e'), ('\U0001d540', '\U0001d544'),
- ('\U0001d546', '\U0001d546'), ('\U0001d54a', '\U0001d550'),
- ('\U0001d56c', '\U0001d585'), ('\U0001d5a0', '\U0001d5b9'),
- ('\U0001d5d4', '\U0001d5ed'), ('\U0001d608', '\U0001d621'),
- ('\U0001d63c', '\U0001d655'), ('\U0001d670', '\U0001d689'),
- ('\U0001d6a8', '\U0001d6c0'), ('\U0001d6e2', '\U0001d6fa'),
- ('\U0001d71c', '\U0001d734'), ('\U0001d756', '\U0001d76e'),
- ('\U0001d790', '\U0001d7a8'), ('\U0001d7ca', '\U0001d7ca')
- ];
-
- pub fn Uppercase(c: char) -> bool {
- super::bsearch_range_table(c, Uppercase_table)
- }
-
- static XID_Continue_table : &'static [(char,char)] = &[
- ('\x30', '\x39'), ('\x41', '\x5a'),
- ('\x5f', '\x5f'), ('\x61', '\x7a'),
- ('\xaa', '\xaa'), ('\xb5', '\xb5'),
- ('\xb7', '\xb7'), ('\xba', '\xba'),
- ('\xc0', '\xd6'), ('\xd8', '\xf6'),
- ('\xf8', '\u01ba'), ('\u01bb', '\u01bb'),
- ('\u01bc', '\u01bf'), ('\u01c0', '\u01c3'),
- ('\u01c4', '\u0293'), ('\u0294', '\u0294'),
- ('\u0295', '\u02af'), ('\u02b0', '\u02c1'),
- ('\u02c6', '\u02d1'), ('\u02e0', '\u02e4'),
- ('\u02ec', '\u02ec'), ('\u02ee', '\u02ee'),
- ('\u0300', '\u036f'), ('\u0370', '\u0373'),
- ('\u0374', '\u0374'), ('\u0376', '\u0377'),
- ('\u037b', '\u037d'), ('\u0386', '\u0386'),
- ('\u0387', '\u0387'), ('\u0388', '\u038a'),
- ('\u038c', '\u038c'), ('\u038e', '\u03a1'),
- ('\u03a3', '\u03f5'), ('\u03f7', '\u0481'),
- ('\u0483', '\u0487'), ('\u048a', '\u0527'),
- ('\u0531', '\u0556'), ('\u0559', '\u0559'),
- ('\u0561', '\u0587'), ('\u0591', '\u05bd'),
- ('\u05bf', '\u05bf'), ('\u05c1', '\u05c2'),
- ('\u05c4', '\u05c5'), ('\u05c7', '\u05c7'),
- ('\u05d0', '\u05ea'), ('\u05f0', '\u05f2'),
- ('\u0610', '\u061a'), ('\u0620', '\u063f'),
- ('\u0640', '\u0640'), ('\u0641', '\u064a'),
- ('\u064b', '\u065f'), ('\u0660', '\u0669'),
- ('\u066e', '\u066f'), ('\u0670', '\u0670'),
- ('\u0671', '\u06d3'), ('\u06d5', '\u06d5'),
- ('\u06d6', '\u06dc'), ('\u06df', '\u06e4'),
- ('\u06e5', '\u06e6'), ('\u06e7', '\u06e8'),
- ('\u06ea', '\u06ed'), ('\u06ee', '\u06ef'),
- ('\u06f0', '\u06f9'), ('\u06fa', '\u06fc'),
- ('\u06ff', '\u06ff'), ('\u0710', '\u0710'),
- ('\u0711', '\u0711'), ('\u0712', '\u072f'),
- ('\u0730', '\u074a'), ('\u074d', '\u07a5'),
- ('\u07a6', '\u07b0'), ('\u07b1', '\u07b1'),
- ('\u07c0', '\u07c9'), ('\u07ca', '\u07ea'),
- ('\u07eb', '\u07f3'), ('\u07f4', '\u07f5'),
- ('\u07fa', '\u07fa'), ('\u0800', '\u0815'),
- ('\u0816', '\u0819'), ('\u081a', '\u081a'),
- ('\u081b', '\u0823'), ('\u0824', '\u0824'),
- ('\u0825', '\u0827'), ('\u0828', '\u0828'),
- ('\u0829', '\u082d'), ('\u0840', '\u0858'),
- ('\u0859', '\u085b'), ('\u08a0', '\u08a0'),
- ('\u08a2', '\u08ac'), ('\u08e4', '\u08fe'),
- ('\u0900', '\u0902'), ('\u0903', '\u0903'),
- ('\u0904', '\u0939'), ('\u093a', '\u093a'),
- ('\u093b', '\u093b'), ('\u093c', '\u093c'),
- ('\u093d', '\u093d'), ('\u093e', '\u0940'),
- ('\u0941', '\u0948'), ('\u0949', '\u094c'),
- ('\u094d', '\u094d'), ('\u094e', '\u094f'),
- ('\u0950', '\u0950'), ('\u0951', '\u0957'),
- ('\u0958', '\u0961'), ('\u0962', '\u0963'),
- ('\u0966', '\u096f'), ('\u0971', '\u0971'),
- ('\u0972', '\u0977'), ('\u0979', '\u097f'),
- ('\u0981', '\u0981'), ('\u0982', '\u0983'),
- ('\u0985', '\u098c'), ('\u098f', '\u0990'),
- ('\u0993', '\u09a8'), ('\u09aa', '\u09b0'),
- ('\u09b2', '\u09b2'), ('\u09b6', '\u09b9'),
- ('\u09bc', '\u09bc'), ('\u09bd', '\u09bd'),
- ('\u09be', '\u09c0'), ('\u09c1', '\u09c4'),
- ('\u09c7', '\u09c8'), ('\u09cb', '\u09cc'),
- ('\u09cd', '\u09cd'), ('\u09ce', '\u09ce'),
- ('\u09d7', '\u09d7'), ('\u09dc', '\u09dd'),
- ('\u09df', '\u09e1'), ('\u09e2', '\u09e3'),
- ('\u09e6', '\u09ef'), ('\u09f0', '\u09f1'),
- ('\u0a01', '\u0a02'), ('\u0a03', '\u0a03'),
- ('\u0a05', '\u0a0a'), ('\u0a0f', '\u0a10'),
- ('\u0a13', '\u0a28'), ('\u0a2a', '\u0a30'),
- ('\u0a32', '\u0a33'), ('\u0a35', '\u0a36'),
- ('\u0a38', '\u0a39'), ('\u0a3c', '\u0a3c'),
- ('\u0a3e', '\u0a40'), ('\u0a41', '\u0a42'),
- ('\u0a47', '\u0a48'), ('\u0a4b', '\u0a4d'),
- ('\u0a51', '\u0a51'), ('\u0a59', '\u0a5c'),
- ('\u0a5e', '\u0a5e'), ('\u0a66', '\u0a6f'),
- ('\u0a70', '\u0a71'), ('\u0a72', '\u0a74'),
- ('\u0a75', '\u0a75'), ('\u0a81', '\u0a82'),
- ('\u0a83', '\u0a83'), ('\u0a85', '\u0a8d'),
- ('\u0a8f', '\u0a91'), ('\u0a93', '\u0aa8'),
- ('\u0aaa', '\u0ab0'), ('\u0ab2', '\u0ab3'),
- ('\u0ab5', '\u0ab9'), ('\u0abc', '\u0abc'),
- ('\u0abd', '\u0abd'), ('\u0abe', '\u0ac0'),
- ('\u0ac1', '\u0ac5'), ('\u0ac7', '\u0ac8'),
- ('\u0ac9', '\u0ac9'), ('\u0acb', '\u0acc'),
- ('\u0acd', '\u0acd'), ('\u0ad0', '\u0ad0'),
- ('\u0ae0', '\u0ae1'), ('\u0ae2', '\u0ae3'),
- ('\u0ae6', '\u0aef'), ('\u0b01', '\u0b01'),
- ('\u0b02', '\u0b03'), ('\u0b05', '\u0b0c'),
- ('\u0b0f', '\u0b10'), ('\u0b13', '\u0b28'),
- ('\u0b2a', '\u0b30'), ('\u0b32', '\u0b33'),
- ('\u0b35', '\u0b39'), ('\u0b3c', '\u0b3c'),
- ('\u0b3d', '\u0b3d'), ('\u0b3e', '\u0b3e'),
- ('\u0b3f', '\u0b3f'), ('\u0b40', '\u0b40'),
- ('\u0b41', '\u0b44'), ('\u0b47', '\u0b48'),
- ('\u0b4b', '\u0b4c'), ('\u0b4d', '\u0b4d'),
- ('\u0b56', '\u0b56'), ('\u0b57', '\u0b57'),
- ('\u0b5c', '\u0b5d'), ('\u0b5f', '\u0b61'),
- ('\u0b62', '\u0b63'), ('\u0b66', '\u0b6f'),
- ('\u0b71', '\u0b71'), ('\u0b82', '\u0b82'),
- ('\u0b83', '\u0b83'), ('\u0b85', '\u0b8a'),
- ('\u0b8e', '\u0b90'), ('\u0b92', '\u0b95'),
- ('\u0b99', '\u0b9a'), ('\u0b9c', '\u0b9c'),
- ('\u0b9e', '\u0b9f'), ('\u0ba3', '\u0ba4'),
- ('\u0ba8', '\u0baa'), ('\u0bae', '\u0bb9'),
- ('\u0bbe', '\u0bbf'), ('\u0bc0', '\u0bc0'),
- ('\u0bc1', '\u0bc2'), ('\u0bc6', '\u0bc8'),
- ('\u0bca', '\u0bcc'), ('\u0bcd', '\u0bcd'),
- ('\u0bd0', '\u0bd0'), ('\u0bd7', '\u0bd7'),
- ('\u0be6', '\u0bef'), ('\u0c01', '\u0c03'),
- ('\u0c05', '\u0c0c'), ('\u0c0e', '\u0c10'),
- ('\u0c12', '\u0c28'), ('\u0c2a', '\u0c33'),
- ('\u0c35', '\u0c39'), ('\u0c3d', '\u0c3d'),
- ('\u0c3e', '\u0c40'), ('\u0c41', '\u0c44'),
- ('\u0c46', '\u0c48'), ('\u0c4a', '\u0c4d'),
- ('\u0c55', '\u0c56'), ('\u0c58', '\u0c59'),
- ('\u0c60', '\u0c61'), ('\u0c62', '\u0c63'),
- ('\u0c66', '\u0c6f'), ('\u0c82', '\u0c83'),
- ('\u0c85', '\u0c8c'), ('\u0c8e', '\u0c90'),
- ('\u0c92', '\u0ca8'), ('\u0caa', '\u0cb3'),
- ('\u0cb5', '\u0cb9'), ('\u0cbc', '\u0cbc'),
- ('\u0cbd', '\u0cbd'), ('\u0cbe', '\u0cbe'),
- ('\u0cbf', '\u0cbf'), ('\u0cc0', '\u0cc4'),
- ('\u0cc6', '\u0cc6'), ('\u0cc7', '\u0cc8'),
- ('\u0cca', '\u0ccb'), ('\u0ccc', '\u0ccd'),
- ('\u0cd5', '\u0cd6'), ('\u0cde', '\u0cde'),
- ('\u0ce0', '\u0ce1'), ('\u0ce2', '\u0ce3'),
- ('\u0ce6', '\u0cef'), ('\u0cf1', '\u0cf2'),
- ('\u0d02', '\u0d03'), ('\u0d05', '\u0d0c'),
- ('\u0d0e', '\u0d10'), ('\u0d12', '\u0d3a'),
- ('\u0d3d', '\u0d3d'), ('\u0d3e', '\u0d40'),
- ('\u0d41', '\u0d44'), ('\u0d46', '\u0d48'),
- ('\u0d4a', '\u0d4c'), ('\u0d4d', '\u0d4d'),
- ('\u0d4e', '\u0d4e'), ('\u0d57', '\u0d57'),
- ('\u0d60', '\u0d61'), ('\u0d62', '\u0d63'),
- ('\u0d66', '\u0d6f'), ('\u0d7a', '\u0d7f'),
- ('\u0d82', '\u0d83'), ('\u0d85', '\u0d96'),
- ('\u0d9a', '\u0db1'), ('\u0db3', '\u0dbb'),
- ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'),
- ('\u0dca', '\u0dca'), ('\u0dcf', '\u0dd1'),
- ('\u0dd2', '\u0dd4'), ('\u0dd6', '\u0dd6'),
- ('\u0dd8', '\u0ddf'), ('\u0df2', '\u0df3'),
- ('\u0e01', '\u0e30'), ('\u0e31', '\u0e31'),
- ('\u0e32', '\u0e33'), ('\u0e34', '\u0e3a'),
- ('\u0e40', '\u0e45'), ('\u0e46', '\u0e46'),
- ('\u0e47', '\u0e4e'), ('\u0e50', '\u0e59'),
- ('\u0e81', '\u0e82'), ('\u0e84', '\u0e84'),
- ('\u0e87', '\u0e88'), ('\u0e8a', '\u0e8a'),
- ('\u0e8d', '\u0e8d'), ('\u0e94', '\u0e97'),
- ('\u0e99', '\u0e9f'), ('\u0ea1', '\u0ea3'),
- ('\u0ea5', '\u0ea5'), ('\u0ea7', '\u0ea7'),
- ('\u0eaa', '\u0eab'), ('\u0ead', '\u0eb0'),
- ('\u0eb1', '\u0eb1'), ('\u0eb2', '\u0eb3'),
- ('\u0eb4', '\u0eb9'), ('\u0ebb', '\u0ebc'),
- ('\u0ebd', '\u0ebd'), ('\u0ec0', '\u0ec4'),
- ('\u0ec6', '\u0ec6'), ('\u0ec8', '\u0ecd'),
- ('\u0ed0', '\u0ed9'), ('\u0edc', '\u0edf'),
- ('\u0f00', '\u0f00'), ('\u0f18', '\u0f19'),
- ('\u0f20', '\u0f29'), ('\u0f35', '\u0f35'),
- ('\u0f37', '\u0f37'), ('\u0f39', '\u0f39'),
- ('\u0f3e', '\u0f3f'), ('\u0f40', '\u0f47'),
- ('\u0f49', '\u0f6c'), ('\u0f71', '\u0f7e'),
- ('\u0f7f', '\u0f7f'), ('\u0f80', '\u0f84'),
- ('\u0f86', '\u0f87'), ('\u0f88', '\u0f8c'),
- ('\u0f8d', '\u0f97'), ('\u0f99', '\u0fbc'),
- ('\u0fc6', '\u0fc6'), ('\u1000', '\u102a'),
- ('\u102b', '\u102c'), ('\u102d', '\u1030'),
- ('\u1031', '\u1031'), ('\u1032', '\u1037'),
- ('\u1038', '\u1038'), ('\u1039', '\u103a'),
- ('\u103b', '\u103c'), ('\u103d', '\u103e'),
- ('\u103f', '\u103f'), ('\u1040', '\u1049'),
- ('\u1050', '\u1055'), ('\u1056', '\u1057'),
- ('\u1058', '\u1059'), ('\u105a', '\u105d'),
- ('\u105e', '\u1060'), ('\u1061', '\u1061'),
- ('\u1062', '\u1064'), ('\u1065', '\u1066'),
- ('\u1067', '\u106d'), ('\u106e', '\u1070'),
- ('\u1071', '\u1074'), ('\u1075', '\u1081'),
- ('\u1082', '\u1082'), ('\u1083', '\u1084'),
- ('\u1085', '\u1086'), ('\u1087', '\u108c'),
- ('\u108d', '\u108d'), ('\u108e', '\u108e'),
- ('\u108f', '\u108f'), ('\u1090', '\u1099'),
- ('\u109a', '\u109c'), ('\u109d', '\u109d'),
- ('\u10a0', '\u10c5'), ('\u10c7', '\u10c7'),
- ('\u10cd', '\u10cd'), ('\u10d0', '\u10fa'),
- ('\u10fc', '\u10fc'), ('\u10fd', '\u1248'),
- ('\u124a', '\u124d'), ('\u1250', '\u1256'),
- ('\u1258', '\u1258'), ('\u125a', '\u125d'),
- ('\u1260', '\u1288'), ('\u128a', '\u128d'),
- ('\u1290', '\u12b0'), ('\u12b2', '\u12b5'),
- ('\u12b8', '\u12be'), ('\u12c0', '\u12c0'),
- ('\u12c2', '\u12c5'), ('\u12c8', '\u12d6'),
- ('\u12d8', '\u1310'), ('\u1312', '\u1315'),
- ('\u1318', '\u135a'), ('\u135d', '\u135f'),
- ('\u1369', '\u1371'), ('\u1380', '\u138f'),
- ('\u13a0', '\u13f4'), ('\u1401', '\u166c'),
- ('\u166f', '\u167f'), ('\u1681', '\u169a'),
- ('\u16a0', '\u16ea'), ('\u16ee', '\u16f0'),
- ('\u1700', '\u170c'), ('\u170e', '\u1711'),
- ('\u1712', '\u1714'), ('\u1720', '\u1731'),
- ('\u1732', '\u1734'), ('\u1740', '\u1751'),
- ('\u1752', '\u1753'), ('\u1760', '\u176c'),
- ('\u176e', '\u1770'), ('\u1772', '\u1773'),
- ('\u1780', '\u17b3'), ('\u17b4', '\u17b5'),
- ('\u17b6', '\u17b6'), ('\u17b7', '\u17bd'),
- ('\u17be', '\u17c5'), ('\u17c6', '\u17c6'),
- ('\u17c7', '\u17c8'), ('\u17c9', '\u17d3'),
- ('\u17d7', '\u17d7'), ('\u17dc', '\u17dc'),
- ('\u17dd', '\u17dd'), ('\u17e0', '\u17e9'),
- ('\u180b', '\u180d'), ('\u1810', '\u1819'),
- ('\u1820', '\u1842'), ('\u1843', '\u1843'),
- ('\u1844', '\u1877'), ('\u1880', '\u18a8'),
- ('\u18a9', '\u18a9'), ('\u18aa', '\u18aa'),
- ('\u18b0', '\u18f5'), ('\u1900', '\u191c'),
- ('\u1920', '\u1922'), ('\u1923', '\u1926'),
- ('\u1927', '\u1928'), ('\u1929', '\u192b'),
- ('\u1930', '\u1931'), ('\u1932', '\u1932'),
- ('\u1933', '\u1938'), ('\u1939', '\u193b'),
- ('\u1946', '\u194f'), ('\u1950', '\u196d'),
- ('\u1970', '\u1974'), ('\u1980', '\u19ab'),
- ('\u19b0', '\u19c0'), ('\u19c1', '\u19c7'),
- ('\u19c8', '\u19c9'), ('\u19d0', '\u19d9'),
- ('\u19da', '\u19da'), ('\u1a00', '\u1a16'),
- ('\u1a17', '\u1a18'), ('\u1a19', '\u1a1a'),
- ('\u1a1b', '\u1a1b'), ('\u1a20', '\u1a54'),
- ('\u1a55', '\u1a55'), ('\u1a56', '\u1a56'),
- ('\u1a57', '\u1a57'), ('\u1a58', '\u1a5e'),
- ('\u1a60', '\u1a60'), ('\u1a61', '\u1a61'),
- ('\u1a62', '\u1a62'), ('\u1a63', '\u1a64'),
- ('\u1a65', '\u1a6c'), ('\u1a6d', '\u1a72'),
- ('\u1a73', '\u1a7c'), ('\u1a7f', '\u1a7f'),
- ('\u1a80', '\u1a89'), ('\u1a90', '\u1a99'),
- ('\u1aa7', '\u1aa7'), ('\u1b00', '\u1b03'),
- ('\u1b04', '\u1b04'), ('\u1b05', '\u1b33'),
- ('\u1b34', '\u1b34'), ('\u1b35', '\u1b35'),
- ('\u1b36', '\u1b3a'), ('\u1b3b', '\u1b3b'),
- ('\u1b3c', '\u1b3c'), ('\u1b3d', '\u1b41'),
- ('\u1b42', '\u1b42'), ('\u1b43', '\u1b44'),
- ('\u1b45', '\u1b4b'), ('\u1b50', '\u1b59'),
- ('\u1b6b', '\u1b73'), ('\u1b80', '\u1b81'),
- ('\u1b82', '\u1b82'), ('\u1b83', '\u1ba0'),
- ('\u1ba1', '\u1ba1'), ('\u1ba2', '\u1ba5'),
- ('\u1ba6', '\u1ba7'), ('\u1ba8', '\u1ba9'),
- ('\u1baa', '\u1baa'), ('\u1bab', '\u1bab'),
- ('\u1bac', '\u1bad'), ('\u1bae', '\u1baf'),
- ('\u1bb0', '\u1bb9'), ('\u1bba', '\u1be5'),
- ('\u1be6', '\u1be6'), ('\u1be7', '\u1be7'),
- ('\u1be8', '\u1be9'), ('\u1bea', '\u1bec'),
- ('\u1bed', '\u1bed'), ('\u1bee', '\u1bee'),
- ('\u1bef', '\u1bf1'), ('\u1bf2', '\u1bf3'),
- ('\u1c00', '\u1c23'), ('\u1c24', '\u1c2b'),
- ('\u1c2c', '\u1c33'), ('\u1c34', '\u1c35'),
- ('\u1c36', '\u1c37'), ('\u1c40', '\u1c49'),
- ('\u1c4d', '\u1c4f'), ('\u1c50', '\u1c59'),
- ('\u1c5a', '\u1c77'), ('\u1c78', '\u1c7d'),
- ('\u1cd0', '\u1cd2'), ('\u1cd4', '\u1ce0'),
- ('\u1ce1', '\u1ce1'), ('\u1ce2', '\u1ce8'),
- ('\u1ce9', '\u1cec'), ('\u1ced', '\u1ced'),
- ('\u1cee', '\u1cf1'), ('\u1cf2', '\u1cf3'),
- ('\u1cf4', '\u1cf4'), ('\u1cf5', '\u1cf6'),
- ('\u1d00', '\u1d2b'), ('\u1d2c', '\u1d6a'),
- ('\u1d6b', '\u1d77'), ('\u1d78', '\u1d78'),
- ('\u1d79', '\u1d9a'), ('\u1d9b', '\u1dbf'),
- ('\u1dc0', '\u1de6'), ('\u1dfc', '\u1dff'),
- ('\u1e00', '\u1f15'), ('\u1f18', '\u1f1d'),
- ('\u1f20', '\u1f45'), ('\u1f48', '\u1f4d'),
- ('\u1f50', '\u1f57'), ('\u1f59', '\u1f59'),
- ('\u1f5b', '\u1f5b'), ('\u1f5d', '\u1f5d'),
- ('\u1f5f', '\u1f7d'), ('\u1f80', '\u1fb4'),
- ('\u1fb6', '\u1fbc'), ('\u1fbe', '\u1fbe'),
- ('\u1fc2', '\u1fc4'), ('\u1fc6', '\u1fcc'),
- ('\u1fd0', '\u1fd3'), ('\u1fd6', '\u1fdb'),
- ('\u1fe0', '\u1fec'), ('\u1ff2', '\u1ff4'),
- ('\u1ff6', '\u1ffc'), ('\u203f', '\u2040'),
- ('\u2054', '\u2054'), ('\u2071', '\u2071'),
- ('\u207f', '\u207f'), ('\u2090', '\u209c'),
- ('\u20d0', '\u20dc'), ('\u20e1', '\u20e1'),
- ('\u20e5', '\u20f0'), ('\u2102', '\u2102'),
- ('\u2107', '\u2107'), ('\u210a', '\u2113'),
- ('\u2115', '\u2115'), ('\u2118', '\u2118'),
- ('\u2119', '\u211d'), ('\u2124', '\u2124'),
- ('\u2126', '\u2126'), ('\u2128', '\u2128'),
- ('\u212a', '\u212d'), ('\u212e', '\u212e'),
- ('\u212f', '\u2134'), ('\u2135', '\u2138'),
- ('\u2139', '\u2139'), ('\u213c', '\u213f'),
- ('\u2145', '\u2149'), ('\u214e', '\u214e'),
- ('\u2160', '\u2182'), ('\u2183', '\u2184'),
- ('\u2185', '\u2188'), ('\u2c00', '\u2c2e'),
- ('\u2c30', '\u2c5e'), ('\u2c60', '\u2c7b'),
- ('\u2c7c', '\u2c7d'), ('\u2c7e', '\u2ce4'),
- ('\u2ceb', '\u2cee'), ('\u2cef', '\u2cf1'),
- ('\u2cf2', '\u2cf3'), ('\u2d00', '\u2d25'),
- ('\u2d27', '\u2d27'), ('\u2d2d', '\u2d2d'),
- ('\u2d30', '\u2d67'), ('\u2d6f', '\u2d6f'),
- ('\u2d7f', '\u2d7f'), ('\u2d80', '\u2d96'),
- ('\u2da0', '\u2da6'), ('\u2da8', '\u2dae'),
- ('\u2db0', '\u2db6'), ('\u2db8', '\u2dbe'),
- ('\u2dc0', '\u2dc6'), ('\u2dc8', '\u2dce'),
- ('\u2dd0', '\u2dd6'), ('\u2dd8', '\u2dde'),
- ('\u2de0', '\u2dff'), ('\u3005', '\u3005'),
- ('\u3006', '\u3006'), ('\u3007', '\u3007'),
- ('\u3021', '\u3029'), ('\u302a', '\u302d'),
- ('\u302e', '\u302f'), ('\u3031', '\u3035'),
- ('\u3038', '\u303a'), ('\u303b', '\u303b'),
- ('\u303c', '\u303c'), ('\u3041', '\u3096'),
- ('\u3099', '\u309a'), ('\u309d', '\u309e'),
- ('\u309f', '\u309f'), ('\u30a1', '\u30fa'),
- ('\u30fc', '\u30fe'), ('\u30ff', '\u30ff'),
- ('\u3105', '\u312d'), ('\u3131', '\u318e'),
- ('\u31a0', '\u31ba'), ('\u31f0', '\u31ff'),
- ('\u3400', '\u4db5'), ('\u4e00', '\u9fcc'),
- ('\ua000', '\ua014'), ('\ua015', '\ua015'),
- ('\ua016', '\ua48c'), ('\ua4d0', '\ua4f7'),
- ('\ua4f8', '\ua4fd'), ('\ua500', '\ua60b'),
- ('\ua60c', '\ua60c'), ('\ua610', '\ua61f'),
- ('\ua620', '\ua629'), ('\ua62a', '\ua62b'),
- ('\ua640', '\ua66d'), ('\ua66e', '\ua66e'),
- ('\ua66f', '\ua66f'), ('\ua674', '\ua67d'),
- ('\ua67f', '\ua67f'), ('\ua680', '\ua697'),
- ('\ua69f', '\ua69f'), ('\ua6a0', '\ua6e5'),
- ('\ua6e6', '\ua6ef'), ('\ua6f0', '\ua6f1'),
- ('\ua717', '\ua71f'), ('\ua722', '\ua76f'),
- ('\ua770', '\ua770'), ('\ua771', '\ua787'),
- ('\ua788', '\ua788'), ('\ua78b', '\ua78e'),
- ('\ua790', '\ua793'), ('\ua7a0', '\ua7aa'),
- ('\ua7f8', '\ua7f9'), ('\ua7fa', '\ua7fa'),
- ('\ua7fb', '\ua801'), ('\ua802', '\ua802'),
- ('\ua803', '\ua805'), ('\ua806', '\ua806'),
- ('\ua807', '\ua80a'), ('\ua80b', '\ua80b'),
- ('\ua80c', '\ua822'), ('\ua823', '\ua824'),
- ('\ua825', '\ua826'), ('\ua827', '\ua827'),
- ('\ua840', '\ua873'), ('\ua880', '\ua881'),
- ('\ua882', '\ua8b3'), ('\ua8b4', '\ua8c3'),
- ('\ua8c4', '\ua8c4'), ('\ua8d0', '\ua8d9'),
- ('\ua8e0', '\ua8f1'), ('\ua8f2', '\ua8f7'),
- ('\ua8fb', '\ua8fb'), ('\ua900', '\ua909'),
- ('\ua90a', '\ua925'), ('\ua926', '\ua92d'),
- ('\ua930', '\ua946'), ('\ua947', '\ua951'),
- ('\ua952', '\ua953'), ('\ua960', '\ua97c'),
- ('\ua980', '\ua982'), ('\ua983', '\ua983'),
- ('\ua984', '\ua9b2'), ('\ua9b3', '\ua9b3'),
- ('\ua9b4', '\ua9b5'), ('\ua9b6', '\ua9b9'),
- ('\ua9ba', '\ua9bb'), ('\ua9bc', '\ua9bc'),
- ('\ua9bd', '\ua9c0'), ('\ua9cf', '\ua9cf'),
- ('\ua9d0', '\ua9d9'), ('\uaa00', '\uaa28'),
- ('\uaa29', '\uaa2e'), ('\uaa2f', '\uaa30'),
- ('\uaa31', '\uaa32'), ('\uaa33', '\uaa34'),
- ('\uaa35', '\uaa36'), ('\uaa40', '\uaa42'),
- ('\uaa43', '\uaa43'), ('\uaa44', '\uaa4b'),
- ('\uaa4c', '\uaa4c'), ('\uaa4d', '\uaa4d'),
- ('\uaa50', '\uaa59'), ('\uaa60', '\uaa6f'),
- ('\uaa70', '\uaa70'), ('\uaa71', '\uaa76'),
- ('\uaa7a', '\uaa7a'), ('\uaa7b', '\uaa7b'),
- ('\uaa80', '\uaaaf'), ('\uaab0', '\uaab0'),
- ('\uaab1', '\uaab1'), ('\uaab2', '\uaab4'),
- ('\uaab5', '\uaab6'), ('\uaab7', '\uaab8'),
- ('\uaab9', '\uaabd'), ('\uaabe', '\uaabf'),
- ('\uaac0', '\uaac0'), ('\uaac1', '\uaac1'),
- ('\uaac2', '\uaac2'), ('\uaadb', '\uaadc'),
- ('\uaadd', '\uaadd'), ('\uaae0', '\uaaea'),
- ('\uaaeb', '\uaaeb'), ('\uaaec', '\uaaed'),
- ('\uaaee', '\uaaef'), ('\uaaf2', '\uaaf2'),
- ('\uaaf3', '\uaaf4'), ('\uaaf5', '\uaaf5'),
- ('\uaaf6', '\uaaf6'), ('\uab01', '\uab06'),
- ('\uab09', '\uab0e'), ('\uab11', '\uab16'),
- ('\uab20', '\uab26'), ('\uab28', '\uab2e'),
- ('\uabc0', '\uabe2'), ('\uabe3', '\uabe4'),
- ('\uabe5', '\uabe5'), ('\uabe6', '\uabe7'),
- ('\uabe8', '\uabe8'), ('\uabe9', '\uabea'),
- ('\uabec', '\uabec'), ('\uabed', '\uabed'),
- ('\uabf0', '\uabf9'), ('\uac00', '\ud7a3'),
- ('\ud7b0', '\ud7c6'), ('\ud7cb', '\ud7fb'),
- ('\uf900', '\ufa6d'), ('\ufa70', '\ufad9'),
- ('\ufb00', '\ufb06'), ('\ufb13', '\ufb17'),
- ('\ufb1d', '\ufb1d'), ('\ufb1e', '\ufb1e'),
- ('\ufb1f', '\ufb28'), ('\ufb2a', '\ufb36'),
- ('\ufb38', '\ufb3c'), ('\ufb3e', '\ufb3e'),
- ('\ufb40', '\ufb41'), ('\ufb43', '\ufb44'),
- ('\ufb46', '\ufbb1'), ('\ufbd3', '\ufc5d'),
- ('\ufc64', '\ufd3d'), ('\ufd50', '\ufd8f'),
- ('\ufd92', '\ufdc7'), ('\ufdf0', '\ufdf9'),
- ('\ufe00', '\ufe0f'), ('\ufe20', '\ufe26'),
- ('\ufe33', '\ufe34'), ('\ufe4d', '\ufe4f'),
- ('\ufe71', '\ufe71'), ('\ufe73', '\ufe73'),
- ('\ufe77', '\ufe77'), ('\ufe79', '\ufe79'),
- ('\ufe7b', '\ufe7b'), ('\ufe7d', '\ufe7d'),
- ('\ufe7f', '\ufefc'), ('\uff10', '\uff19'),
- ('\uff21', '\uff3a'), ('\uff3f', '\uff3f'),
- ('\uff41', '\uff5a'), ('\uff66', '\uff6f'),
- ('\uff70', '\uff70'), ('\uff71', '\uff9d'),
- ('\uff9e', '\uff9f'), ('\uffa0', '\uffbe'),
- ('\uffc2', '\uffc7'), ('\uffca', '\uffcf'),
- ('\uffd2', '\uffd7'), ('\uffda', '\uffdc'),
- ('\U00010000', '\U0001000b'), ('\U0001000d', '\U00010026'),
- ('\U00010028', '\U0001003a'), ('\U0001003c', '\U0001003d'),
- ('\U0001003f', '\U0001004d'), ('\U00010050', '\U0001005d'),
- ('\U00010080', '\U000100fa'), ('\U00010140', '\U00010174'),
- ('\U000101fd', '\U000101fd'), ('\U00010280', '\U0001029c'),
- ('\U000102a0', '\U000102d0'), ('\U00010300', '\U0001031e'),
- ('\U00010330', '\U00010340'), ('\U00010341', '\U00010341'),
- ('\U00010342', '\U00010349'), ('\U0001034a', '\U0001034a'),
- ('\U00010380', '\U0001039d'), ('\U000103a0', '\U000103c3'),
- ('\U000103c8', '\U000103cf'), ('\U000103d1', '\U000103d5'),
- ('\U00010400', '\U0001044f'), ('\U00010450', '\U0001049d'),
- ('\U000104a0', '\U000104a9'), ('\U00010800', '\U00010805'),
- ('\U00010808', '\U00010808'), ('\U0001080a', '\U00010835'),
- ('\U00010837', '\U00010838'), ('\U0001083c', '\U0001083c'),
- ('\U0001083f', '\U00010855'), ('\U00010900', '\U00010915'),
- ('\U00010920', '\U00010939'), ('\U00010980', '\U000109b7'),
- ('\U000109be', '\U000109bf'), ('\U00010a00', '\U00010a00'),
- ('\U00010a01', '\U00010a03'), ('\U00010a05', '\U00010a06'),
- ('\U00010a0c', '\U00010a0f'), ('\U00010a10', '\U00010a13'),
- ('\U00010a15', '\U00010a17'), ('\U00010a19', '\U00010a33'),
- ('\U00010a38', '\U00010a3a'), ('\U00010a3f', '\U00010a3f'),
- ('\U00010a60', '\U00010a7c'), ('\U00010b00', '\U00010b35'),
- ('\U00010b40', '\U00010b55'), ('\U00010b60', '\U00010b72'),
- ('\U00010c00', '\U00010c48'), ('\U00011000', '\U00011000'),
- ('\U00011001', '\U00011001'), ('\U00011002', '\U00011002'),
- ('\U00011003', '\U00011037'), ('\U00011038', '\U00011046'),
- ('\U00011066', '\U0001106f'), ('\U00011080', '\U00011081'),
- ('\U00011082', '\U00011082'), ('\U00011083', '\U000110af'),
- ('\U000110b0', '\U000110b2'), ('\U000110b3', '\U000110b6'),
- ('\U000110b7', '\U000110b8'), ('\U000110b9', '\U000110ba'),
- ('\U000110d0', '\U000110e8'), ('\U000110f0', '\U000110f9'),
- ('\U00011100', '\U00011102'), ('\U00011103', '\U00011126'),
- ('\U00011127', '\U0001112b'), ('\U0001112c', '\U0001112c'),
- ('\U0001112d', '\U00011134'), ('\U00011136', '\U0001113f'),
- ('\U00011180', '\U00011181'), ('\U00011182', '\U00011182'),
- ('\U00011183', '\U000111b2'), ('\U000111b3', '\U000111b5'),
- ('\U000111b6', '\U000111be'), ('\U000111bf', '\U000111c0'),
- ('\U000111c1', '\U000111c4'), ('\U000111d0', '\U000111d9'),
- ('\U00011680', '\U000116aa'), ('\U000116ab', '\U000116ab'),
- ('\U000116ac', '\U000116ac'), ('\U000116ad', '\U000116ad'),
- ('\U000116ae', '\U000116af'), ('\U000116b0', '\U000116b5'),
- ('\U000116b6', '\U000116b6'), ('\U000116b7', '\U000116b7'),
- ('\U000116c0', '\U000116c9'), ('\U00012000', '\U0001236e'),
- ('\U00012400', '\U00012462'), ('\U00013000', '\U0001342e'),
- ('\U00016800', '\U00016a38'), ('\U00016f00', '\U00016f44'),
- ('\U00016f50', '\U00016f50'), ('\U00016f51', '\U00016f7e'),
- ('\U00016f8f', '\U00016f92'), ('\U00016f93', '\U00016f9f'),
- ('\U0001b000', '\U0001b001'), ('\U0001d165', '\U0001d166'),
- ('\U0001d167', '\U0001d169'), ('\U0001d16d', '\U0001d172'),
- ('\U0001d17b', '\U0001d182'), ('\U0001d185', '\U0001d18b'),
- ('\U0001d1aa', '\U0001d1ad'), ('\U0001d242', '\U0001d244'),
- ('\U0001d400', '\U0001d454'), ('\U0001d456', '\U0001d49c'),
- ('\U0001d49e', '\U0001d49f'), ('\U0001d4a2', '\U0001d4a2'),
- ('\U0001d4a5', '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'),
- ('\U0001d4ae', '\U0001d4b9'), ('\U0001d4bb', '\U0001d4bb'),
- ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5', '\U0001d505'),
- ('\U0001d507', '\U0001d50a'), ('\U0001d50d', '\U0001d514'),
- ('\U0001d516', '\U0001d51c'), ('\U0001d51e', '\U0001d539'),
- ('\U0001d53b', '\U0001d53e'), ('\U0001d540', '\U0001d544'),
- ('\U0001d546', '\U0001d546'), ('\U0001d54a', '\U0001d550'),
- ('\U0001d552', '\U0001d6a5'), ('\U0001d6a8', '\U0001d6c0'),
- ('\U0001d6c2', '\U0001d6da'), ('\U0001d6dc', '\U0001d6fa'),
- ('\U0001d6fc', '\U0001d714'), ('\U0001d716', '\U0001d734'),
- ('\U0001d736', '\U0001d74e'), ('\U0001d750', '\U0001d76e'),
- ('\U0001d770', '\U0001d788'), ('\U0001d78a', '\U0001d7a8'),
- ('\U0001d7aa', '\U0001d7c2'), ('\U0001d7c4', '\U0001d7cb'),
- ('\U0001d7ce', '\U0001d7ff'), ('\U0001ee00', '\U0001ee03'),
- ('\U0001ee05', '\U0001ee1f'), ('\U0001ee21', '\U0001ee22'),
- ('\U0001ee24', '\U0001ee24'), ('\U0001ee27', '\U0001ee27'),
- ('\U0001ee29', '\U0001ee32'), ('\U0001ee34', '\U0001ee37'),
- ('\U0001ee39', '\U0001ee39'), ('\U0001ee3b', '\U0001ee3b'),
- ('\U0001ee42', '\U0001ee42'), ('\U0001ee47', '\U0001ee47'),
- ('\U0001ee49', '\U0001ee49'), ('\U0001ee4b', '\U0001ee4b'),
- ('\U0001ee4d', '\U0001ee4f'), ('\U0001ee51', '\U0001ee52'),
- ('\U0001ee54', '\U0001ee54'), ('\U0001ee57', '\U0001ee57'),
- ('\U0001ee59', '\U0001ee59'), ('\U0001ee5b', '\U0001ee5b'),
- ('\U0001ee5d', '\U0001ee5d'), ('\U0001ee5f', '\U0001ee5f'),
- ('\U0001ee61', '\U0001ee62'), ('\U0001ee64', '\U0001ee64'),
- ('\U0001ee67', '\U0001ee6a'), ('\U0001ee6c', '\U0001ee72'),
- ('\U0001ee74', '\U0001ee77'), ('\U0001ee79', '\U0001ee7c'),
- ('\U0001ee7e', '\U0001ee7e'), ('\U0001ee80', '\U0001ee89'),
- ('\U0001ee8b', '\U0001ee9b'), ('\U0001eea1', '\U0001eea3'),
- ('\U0001eea5', '\U0001eea9'), ('\U0001eeab', '\U0001eebb'),
- ('\U00020000', '\U0002a6d6'), ('\U0002a700', '\U0002b734'),
- ('\U0002b740', '\U0002b81d'), ('\U0002f800', '\U0002fa1d'),
- ('\U000e0100', '\U000e01ef')
- ];
-
- pub fn XID_Continue(c: char) -> bool {
- super::bsearch_range_table(c, XID_Continue_table)
- }
-
- static XID_Start_table : &'static [(char,char)] = &[
- ('\x41', '\x5a'), ('\x61', '\x7a'),
- ('\xaa', '\xaa'), ('\xb5', '\xb5'),
- ('\xba', '\xba'), ('\xc0', '\xd6'),
- ('\xd8', '\xf6'), ('\xf8', '\u01ba'),
- ('\u01bb', '\u01bb'), ('\u01bc', '\u01bf'),
- ('\u01c0', '\u01c3'), ('\u01c4', '\u0293'),
- ('\u0294', '\u0294'), ('\u0295', '\u02af'),
- ('\u02b0', '\u02c1'), ('\u02c6', '\u02d1'),
- ('\u02e0', '\u02e4'), ('\u02ec', '\u02ec'),
- ('\u02ee', '\u02ee'), ('\u0370', '\u0373'),
- ('\u0374', '\u0374'), ('\u0376', '\u0377'),
- ('\u037b', '\u037d'), ('\u0386', '\u0386'),
- ('\u0388', '\u038a'), ('\u038c', '\u038c'),
- ('\u038e', '\u03a1'), ('\u03a3', '\u03f5'),
- ('\u03f7', '\u0481'), ('\u048a', '\u0527'),
- ('\u0531', '\u0556'), ('\u0559', '\u0559'),
- ('\u0561', '\u0587'), ('\u05d0', '\u05ea'),
- ('\u05f0', '\u05f2'), ('\u0620', '\u063f'),
- ('\u0640', '\u0640'), ('\u0641', '\u064a'),
- ('\u066e', '\u066f'), ('\u0671', '\u06d3'),
- ('\u06d5', '\u06d5'), ('\u06e5', '\u06e6'),
- ('\u06ee', '\u06ef'), ('\u06fa', '\u06fc'),
- ('\u06ff', '\u06ff'), ('\u0710', '\u0710'),
- ('\u0712', '\u072f'), ('\u074d', '\u07a5'),
- ('\u07b1', '\u07b1'), ('\u07ca', '\u07ea'),
- ('\u07f4', '\u07f5'), ('\u07fa', '\u07fa'),
- ('\u0800', '\u0815'), ('\u081a', '\u081a'),
- ('\u0824', '\u0824'), ('\u0828', '\u0828'),
- ('\u0840', '\u0858'), ('\u08a0', '\u08a0'),
- ('\u08a2', '\u08ac'), ('\u0904', '\u0939'),
- ('\u093d', '\u093d'), ('\u0950', '\u0950'),
- ('\u0958', '\u0961'), ('\u0971', '\u0971'),
- ('\u0972', '\u0977'), ('\u0979', '\u097f'),
- ('\u0985', '\u098c'), ('\u098f', '\u0990'),
- ('\u0993', '\u09a8'), ('\u09aa', '\u09b0'),
- ('\u09b2', '\u09b2'), ('\u09b6', '\u09b9'),
- ('\u09bd', '\u09bd'), ('\u09ce', '\u09ce'),
- ('\u09dc', '\u09dd'), ('\u09df', '\u09e1'),
- ('\u09f0', '\u09f1'), ('\u0a05', '\u0a0a'),
- ('\u0a0f', '\u0a10'), ('\u0a13', '\u0a28'),
- ('\u0a2a', '\u0a30'), ('\u0a32', '\u0a33'),
- ('\u0a35', '\u0a36'), ('\u0a38', '\u0a39'),
- ('\u0a59', '\u0a5c'), ('\u0a5e', '\u0a5e'),
- ('\u0a72', '\u0a74'), ('\u0a85', '\u0a8d'),
- ('\u0a8f', '\u0a91'), ('\u0a93', '\u0aa8'),
- ('\u0aaa', '\u0ab0'), ('\u0ab2', '\u0ab3'),
- ('\u0ab5', '\u0ab9'), ('\u0abd', '\u0abd'),
- ('\u0ad0', '\u0ad0'), ('\u0ae0', '\u0ae1'),
- ('\u0b05', '\u0b0c'), ('\u0b0f', '\u0b10'),
- ('\u0b13', '\u0b28'), ('\u0b2a', '\u0b30'),
- ('\u0b32', '\u0b33'), ('\u0b35', '\u0b39'),
- ('\u0b3d', '\u0b3d'), ('\u0b5c', '\u0b5d'),
- ('\u0b5f', '\u0b61'), ('\u0b71', '\u0b71'),
- ('\u0b83', '\u0b83'), ('\u0b85', '\u0b8a'),
- ('\u0b8e', '\u0b90'), ('\u0b92', '\u0b95'),
- ('\u0b99', '\u0b9a'), ('\u0b9c', '\u0b9c'),
- ('\u0b9e', '\u0b9f'), ('\u0ba3', '\u0ba4'),
- ('\u0ba8', '\u0baa'), ('\u0bae', '\u0bb9'),
- ('\u0bd0', '\u0bd0'), ('\u0c05', '\u0c0c'),
- ('\u0c0e', '\u0c10'), ('\u0c12', '\u0c28'),
- ('\u0c2a', '\u0c33'), ('\u0c35', '\u0c39'),
- ('\u0c3d', '\u0c3d'), ('\u0c58', '\u0c59'),
- ('\u0c60', '\u0c61'), ('\u0c85', '\u0c8c'),
- ('\u0c8e', '\u0c90'), ('\u0c92', '\u0ca8'),
- ('\u0caa', '\u0cb3'), ('\u0cb5', '\u0cb9'),
- ('\u0cbd', '\u0cbd'), ('\u0cde', '\u0cde'),
- ('\u0ce0', '\u0ce1'), ('\u0cf1', '\u0cf2'),
- ('\u0d05', '\u0d0c'), ('\u0d0e', '\u0d10'),
- ('\u0d12', '\u0d3a'), ('\u0d3d', '\u0d3d'),
- ('\u0d4e', '\u0d4e'), ('\u0d60', '\u0d61'),
- ('\u0d7a', '\u0d7f'), ('\u0d85', '\u0d96'),
- ('\u0d9a', '\u0db1'), ('\u0db3', '\u0dbb'),
- ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'),
- ('\u0e01', '\u0e30'), ('\u0e32', '\u0e32'),
- ('\u0e40', '\u0e45'), ('\u0e46', '\u0e46'),
- ('\u0e81', '\u0e82'), ('\u0e84', '\u0e84'),
- ('\u0e87', '\u0e88'), ('\u0e8a', '\u0e8a'),
- ('\u0e8d', '\u0e8d'), ('\u0e94', '\u0e97'),
- ('\u0e99', '\u0e9f'), ('\u0ea1', '\u0ea3'),
- ('\u0ea5', '\u0ea5'), ('\u0ea7', '\u0ea7'),
- ('\u0eaa', '\u0eab'), ('\u0ead', '\u0eb0'),
- ('\u0eb2', '\u0eb2'), ('\u0ebd', '\u0ebd'),
- ('\u0ec0', '\u0ec4'), ('\u0ec6', '\u0ec6'),
- ('\u0edc', '\u0edf'), ('\u0f00', '\u0f00'),
- ('\u0f40', '\u0f47'), ('\u0f49', '\u0f6c'),
- ('\u0f88', '\u0f8c'), ('\u1000', '\u102a'),
- ('\u103f', '\u103f'), ('\u1050', '\u1055'),
- ('\u105a', '\u105d'), ('\u1061', '\u1061'),
- ('\u1065', '\u1066'), ('\u106e', '\u1070'),
- ('\u1075', '\u1081'), ('\u108e', '\u108e'),
- ('\u10a0', '\u10c5'), ('\u10c7', '\u10c7'),
- ('\u10cd', '\u10cd'), ('\u10d0', '\u10fa'),
- ('\u10fc', '\u10fc'), ('\u10fd', '\u1248'),
- ('\u124a', '\u124d'), ('\u1250', '\u1256'),
- ('\u1258', '\u1258'), ('\u125a', '\u125d'),
- ('\u1260', '\u1288'), ('\u128a', '\u128d'),
- ('\u1290', '\u12b0'), ('\u12b2', '\u12b5'),
- ('\u12b8', '\u12be'), ('\u12c0', '\u12c0'),
- ('\u12c2', '\u12c5'), ('\u12c8', '\u12d6'),
- ('\u12d8', '\u1310'), ('\u1312', '\u1315'),
- ('\u1318', '\u135a'), ('\u1380', '\u138f'),
- ('\u13a0', '\u13f4'), ('\u1401', '\u166c'),
- ('\u166f', '\u167f'), ('\u1681', '\u169a'),
- ('\u16a0', '\u16ea'), ('\u16ee', '\u16f0'),
- ('\u1700', '\u170c'), ('\u170e', '\u1711'),
- ('\u1720', '\u1731'), ('\u1740', '\u1751'),
- ('\u1760', '\u176c'), ('\u176e', '\u1770'),
- ('\u1780', '\u17b3'), ('\u17d7', '\u17d7'),
- ('\u17dc', '\u17dc'), ('\u1820', '\u1842'),
- ('\u1843', '\u1843'), ('\u1844', '\u1877'),
- ('\u1880', '\u18a8'), ('\u18aa', '\u18aa'),
- ('\u18b0', '\u18f5'), ('\u1900', '\u191c'),
- ('\u1950', '\u196d'), ('\u1970', '\u1974'),
- ('\u1980', '\u19ab'), ('\u19c1', '\u19c7'),
- ('\u1a00', '\u1a16'), ('\u1a20', '\u1a54'),
- ('\u1aa7', '\u1aa7'), ('\u1b05', '\u1b33'),
- ('\u1b45', '\u1b4b'), ('\u1b83', '\u1ba0'),
- ('\u1bae', '\u1baf'), ('\u1bba', '\u1be5'),
- ('\u1c00', '\u1c23'), ('\u1c4d', '\u1c4f'),
- ('\u1c5a', '\u1c77'), ('\u1c78', '\u1c7d'),
- ('\u1ce9', '\u1cec'), ('\u1cee', '\u1cf1'),
- ('\u1cf5', '\u1cf6'), ('\u1d00', '\u1d2b'),
- ('\u1d2c', '\u1d6a'), ('\u1d6b', '\u1d77'),
- ('\u1d78', '\u1d78'), ('\u1d79', '\u1d9a'),
- ('\u1d9b', '\u1dbf'), ('\u1e00', '\u1f15'),
- ('\u1f18', '\u1f1d'), ('\u1f20', '\u1f45'),
- ('\u1f48', '\u1f4d'), ('\u1f50', '\u1f57'),
- ('\u1f59', '\u1f59'), ('\u1f5b', '\u1f5b'),
- ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f7d'),
- ('\u1f80', '\u1fb4'), ('\u1fb6', '\u1fbc'),
- ('\u1fbe', '\u1fbe'), ('\u1fc2', '\u1fc4'),
- ('\u1fc6', '\u1fcc'), ('\u1fd0', '\u1fd3'),
- ('\u1fd6', '\u1fdb'), ('\u1fe0', '\u1fec'),
- ('\u1ff2', '\u1ff4'), ('\u1ff6', '\u1ffc'),
- ('\u2071', '\u2071'), ('\u207f', '\u207f'),
- ('\u2090', '\u209c'), ('\u2102', '\u2102'),
- ('\u2107', '\u2107'), ('\u210a', '\u2113'),
- ('\u2115', '\u2115'), ('\u2118', '\u2118'),
- ('\u2119', '\u211d'), ('\u2124', '\u2124'),
- ('\u2126', '\u2126'), ('\u2128', '\u2128'),
- ('\u212a', '\u212d'), ('\u212e', '\u212e'),
- ('\u212f', '\u2134'), ('\u2135', '\u2138'),
- ('\u2139', '\u2139'), ('\u213c', '\u213f'),
- ('\u2145', '\u2149'), ('\u214e', '\u214e'),
- ('\u2160', '\u2182'), ('\u2183', '\u2184'),
- ('\u2185', '\u2188'), ('\u2c00', '\u2c2e'),
- ('\u2c30', '\u2c5e'), ('\u2c60', '\u2c7b'),
- ('\u2c7c', '\u2c7d'), ('\u2c7e', '\u2ce4'),
- ('\u2ceb', '\u2cee'), ('\u2cf2', '\u2cf3'),
- ('\u2d00', '\u2d25'), ('\u2d27', '\u2d27'),
- ('\u2d2d', '\u2d2d'), ('\u2d30', '\u2d67'),
- ('\u2d6f', '\u2d6f'), ('\u2d80', '\u2d96'),
- ('\u2da0', '\u2da6'), ('\u2da8', '\u2dae'),
- ('\u2db0', '\u2db6'), ('\u2db8', '\u2dbe'),
- ('\u2dc0', '\u2dc6'), ('\u2dc8', '\u2dce'),
- ('\u2dd0', '\u2dd6'), ('\u2dd8', '\u2dde'),
- ('\u3005', '\u3005'), ('\u3006', '\u3006'),
- ('\u3007', '\u3007'), ('\u3021', '\u3029'),
- ('\u3031', '\u3035'), ('\u3038', '\u303a'),
- ('\u303b', '\u303b'), ('\u303c', '\u303c'),
- ('\u3041', '\u3096'), ('\u309d', '\u309e'),
- ('\u309f', '\u309f'), ('\u30a1', '\u30fa'),
- ('\u30fc', '\u30fe'), ('\u30ff', '\u30ff'),
- ('\u3105', '\u312d'), ('\u3131', '\u318e'),
- ('\u31a0', '\u31ba'), ('\u31f0', '\u31ff'),
- ('\u3400', '\u4db5'), ('\u4e00', '\u9fcc'),
- ('\ua000', '\ua014'), ('\ua015', '\ua015'),
- ('\ua016', '\ua48c'), ('\ua4d0', '\ua4f7'),
- ('\ua4f8', '\ua4fd'), ('\ua500', '\ua60b'),
- ('\ua60c', '\ua60c'), ('\ua610', '\ua61f'),
- ('\ua62a', '\ua62b'), ('\ua640', '\ua66d'),
- ('\ua66e', '\ua66e'), ('\ua67f', '\ua67f'),
- ('\ua680', '\ua697'), ('\ua6a0', '\ua6e5'),
- ('\ua6e6', '\ua6ef'), ('\ua717', '\ua71f'),
- ('\ua722', '\ua76f'), ('\ua770', '\ua770'),
- ('\ua771', '\ua787'), ('\ua788', '\ua788'),
- ('\ua78b', '\ua78e'), ('\ua790', '\ua793'),
- ('\ua7a0', '\ua7aa'), ('\ua7f8', '\ua7f9'),
- ('\ua7fa', '\ua7fa'), ('\ua7fb', '\ua801'),
- ('\ua803', '\ua805'), ('\ua807', '\ua80a'),
- ('\ua80c', '\ua822'), ('\ua840', '\ua873'),
- ('\ua882', '\ua8b3'), ('\ua8f2', '\ua8f7'),
- ('\ua8fb', '\ua8fb'), ('\ua90a', '\ua925'),
- ('\ua930', '\ua946'), ('\ua960', '\ua97c'),
- ('\ua984', '\ua9b2'), ('\ua9cf', '\ua9cf'),
- ('\uaa00', '\uaa28'), ('\uaa40', '\uaa42'),
- ('\uaa44', '\uaa4b'), ('\uaa60', '\uaa6f'),
- ('\uaa70', '\uaa70'), ('\uaa71', '\uaa76'),
- ('\uaa7a', '\uaa7a'), ('\uaa80', '\uaaaf'),
- ('\uaab1', '\uaab1'), ('\uaab5', '\uaab6'),
- ('\uaab9', '\uaabd'), ('\uaac0', '\uaac0'),
- ('\uaac2', '\uaac2'), ('\uaadb', '\uaadc'),
- ('\uaadd', '\uaadd'), ('\uaae0', '\uaaea'),
- ('\uaaf2', '\uaaf2'), ('\uaaf3', '\uaaf4'),
- ('\uab01', '\uab06'), ('\uab09', '\uab0e'),
- ('\uab11', '\uab16'), ('\uab20', '\uab26'),
- ('\uab28', '\uab2e'), ('\uabc0', '\uabe2'),
- ('\uac00', '\ud7a3'), ('\ud7b0', '\ud7c6'),
- ('\ud7cb', '\ud7fb'), ('\uf900', '\ufa6d'),
- ('\ufa70', '\ufad9'), ('\ufb00', '\ufb06'),
- ('\ufb13', '\ufb17'), ('\ufb1d', '\ufb1d'),
- ('\ufb1f', '\ufb28'), ('\ufb2a', '\ufb36'),
- ('\ufb38', '\ufb3c'), ('\ufb3e', '\ufb3e'),
- ('\ufb40', '\ufb41'), ('\ufb43', '\ufb44'),
- ('\ufb46', '\ufbb1'), ('\ufbd3', '\ufc5d'),
- ('\ufc64', '\ufd3d'), ('\ufd50', '\ufd8f'),
- ('\ufd92', '\ufdc7'), ('\ufdf0', '\ufdf9'),
- ('\ufe71', '\ufe71'), ('\ufe73', '\ufe73'),
- ('\ufe77', '\ufe77'), ('\ufe79', '\ufe79'),
- ('\ufe7b', '\ufe7b'), ('\ufe7d', '\ufe7d'),
- ('\ufe7f', '\ufefc'), ('\uff21', '\uff3a'),
- ('\uff41', '\uff5a'), ('\uff66', '\uff6f'),
- ('\uff70', '\uff70'), ('\uff71', '\uff9d'),
- ('\uffa0', '\uffbe'), ('\uffc2', '\uffc7'),
- ('\uffca', '\uffcf'), ('\uffd2', '\uffd7'),
- ('\uffda', '\uffdc'), ('\U00010000', '\U0001000b'),
- ('\U0001000d', '\U00010026'), ('\U00010028', '\U0001003a'),
- ('\U0001003c', '\U0001003d'), ('\U0001003f', '\U0001004d'),
- ('\U00010050', '\U0001005d'), ('\U00010080', '\U000100fa'),
- ('\U00010140', '\U00010174'), ('\U00010280', '\U0001029c'),
- ('\U000102a0', '\U000102d0'), ('\U00010300', '\U0001031e'),
- ('\U00010330', '\U00010340'), ('\U00010341', '\U00010341'),
- ('\U00010342', '\U00010349'), ('\U0001034a', '\U0001034a'),
- ('\U00010380', '\U0001039d'), ('\U000103a0', '\U000103c3'),
- ('\U000103c8', '\U000103cf'), ('\U000103d1', '\U000103d5'),
- ('\U00010400', '\U0001044f'), ('\U00010450', '\U0001049d'),
- ('\U00010800', '\U00010805'), ('\U00010808', '\U00010808'),
- ('\U0001080a', '\U00010835'), ('\U00010837', '\U00010838'),
- ('\U0001083c', '\U0001083c'), ('\U0001083f', '\U00010855'),
- ('\U00010900', '\U00010915'), ('\U00010920', '\U00010939'),
- ('\U00010980', '\U000109b7'), ('\U000109be', '\U000109bf'),
- ('\U00010a00', '\U00010a00'), ('\U00010a10', '\U00010a13'),
- ('\U00010a15', '\U00010a17'), ('\U00010a19', '\U00010a33'),
- ('\U00010a60', '\U00010a7c'), ('\U00010b00', '\U00010b35'),
- ('\U00010b40', '\U00010b55'), ('\U00010b60', '\U00010b72'),
- ('\U00010c00', '\U00010c48'), ('\U00011003', '\U00011037'),
- ('\U00011083', '\U000110af'), ('\U000110d0', '\U000110e8'),
- ('\U00011103', '\U00011126'), ('\U00011183', '\U000111b2'),
- ('\U000111c1', '\U000111c4'), ('\U00011680', '\U000116aa'),
- ('\U00012000', '\U0001236e'), ('\U00012400', '\U00012462'),
- ('\U00013000', '\U0001342e'), ('\U00016800', '\U00016a38'),
- ('\U00016f00', '\U00016f44'), ('\U00016f50', '\U00016f50'),
- ('\U00016f93', '\U00016f9f'), ('\U0001b000', '\U0001b001'),
- ('\U0001d400', '\U0001d454'), ('\U0001d456', '\U0001d49c'),
- ('\U0001d49e', '\U0001d49f'), ('\U0001d4a2', '\U0001d4a2'),
- ('\U0001d4a5', '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'),
- ('\U0001d4ae', '\U0001d4b9'), ('\U0001d4bb', '\U0001d4bb'),
- ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5', '\U0001d505'),
- ('\U0001d507', '\U0001d50a'), ('\U0001d50d', '\U0001d514'),
- ('\U0001d516', '\U0001d51c'), ('\U0001d51e', '\U0001d539'),
- ('\U0001d53b', '\U0001d53e'), ('\U0001d540', '\U0001d544'),
- ('\U0001d546', '\U0001d546'), ('\U0001d54a', '\U0001d550'),
- ('\U0001d552', '\U0001d6a5'), ('\U0001d6a8', '\U0001d6c0'),
- ('\U0001d6c2', '\U0001d6da'), ('\U0001d6dc', '\U0001d6fa'),
- ('\U0001d6fc', '\U0001d714'), ('\U0001d716', '\U0001d734'),
- ('\U0001d736', '\U0001d74e'), ('\U0001d750', '\U0001d76e'),
- ('\U0001d770', '\U0001d788'), ('\U0001d78a', '\U0001d7a8'),
- ('\U0001d7aa', '\U0001d7c2'), ('\U0001d7c4', '\U0001d7cb'),
- ('\U0001ee00', '\U0001ee03'), ('\U0001ee05', '\U0001ee1f'),
- ('\U0001ee21', '\U0001ee22'), ('\U0001ee24', '\U0001ee24'),
- ('\U0001ee27', '\U0001ee27'), ('\U0001ee29', '\U0001ee32'),
- ('\U0001ee34', '\U0001ee37'), ('\U0001ee39', '\U0001ee39'),
- ('\U0001ee3b', '\U0001ee3b'), ('\U0001ee42', '\U0001ee42'),
- ('\U0001ee47', '\U0001ee47'), ('\U0001ee49', '\U0001ee49'),
- ('\U0001ee4b', '\U0001ee4b'), ('\U0001ee4d', '\U0001ee4f'),
- ('\U0001ee51', '\U0001ee52'), ('\U0001ee54', '\U0001ee54'),
- ('\U0001ee57', '\U0001ee57'), ('\U0001ee59', '\U0001ee59'),
- ('\U0001ee5b', '\U0001ee5b'), ('\U0001ee5d', '\U0001ee5d'),
- ('\U0001ee5f', '\U0001ee5f'), ('\U0001ee61', '\U0001ee62'),
- ('\U0001ee64', '\U0001ee64'), ('\U0001ee67', '\U0001ee6a'),
- ('\U0001ee6c', '\U0001ee72'), ('\U0001ee74', '\U0001ee77'),
- ('\U0001ee79', '\U0001ee7c'), ('\U0001ee7e', '\U0001ee7e'),
- ('\U0001ee80', '\U0001ee89'), ('\U0001ee8b', '\U0001ee9b'),
- ('\U0001eea1', '\U0001eea3'), ('\U0001eea5', '\U0001eea9'),
- ('\U0001eeab', '\U0001eebb'), ('\U00020000', '\U0002a6d6'),
- ('\U0002a700', '\U0002b734'), ('\U0002b740', '\U0002b81d'),
- ('\U0002f800', '\U0002fa1d')
- ];
-
- pub fn XID_Start(c: char) -> bool {
- super::bsearch_range_table(c, XID_Start_table)
- }
-
-}
-
-pub mod property {
- static White_Space_table : &'static [(char,char)] = &[
- ('\x09', '\x0d'), ('\x20', '\x20'),
- ('\x85', '\x85'), ('\xa0', '\xa0'),
- ('\u1680', '\u1680'), ('\u2000', '\u200a'),
- ('\u2028', '\u2028'), ('\u2029', '\u2029'),
- ('\u202f', '\u202f'), ('\u205f', '\u205f'),
- ('\u3000', '\u3000')
- ];
-
- pub fn White_Space(c: char) -> bool {
- super::bsearch_range_table(c, White_Space_table)
- }
-
-}
-
-pub mod conversions {
- use cmp::{Equal, Less, Greater};
- use slice::ImmutableVector;
- use tuple::Tuple2;
- use option::{Option, Some, None};
-
- pub fn to_lower(c: char) -> char {
- match bsearch_case_table(c, LuLl_table) {
- None => c,
- Some(index) => LuLl_table[index].val1()
- }
- }
-
- pub fn to_upper(c: char) -> char {
- match bsearch_case_table(c, LlLu_table) {
- None => c,
- Some(index) => LlLu_table[index].val1()
- }
- }
-
- fn bsearch_case_table(c: char, table: &'static [(char, char)]) -> Option<uint> {
- table.bsearch(|&(key, _)| {
- if c == key { Equal }
- else if key < c { Less }
- else { Greater }
- })
- }
-
- static LuLl_table : &'static [(char, char)] = &[
- ('\x41', '\x61'), ('\x42', '\x62'),
- ('\x43', '\x63'), ('\x44', '\x64'),
- ('\x45', '\x65'), ('\x46', '\x66'),
- ('\x47', '\x67'), ('\x48', '\x68'),
- ('\x49', '\x69'), ('\x4a', '\x6a'),
- ('\x4b', '\x6b'), ('\x4c', '\x6c'),
- ('\x4d', '\x6d'), ('\x4e', '\x6e'),
- ('\x4f', '\x6f'), ('\x50', '\x70'),
- ('\x51', '\x71'), ('\x52', '\x72'),
- ('\x53', '\x73'), ('\x54', '\x74'),
- ('\x55', '\x75'), ('\x56', '\x76'),
- ('\x57', '\x77'), ('\x58', '\x78'),
- ('\x59', '\x79'), ('\x5a', '\x7a'),
- ('\xc0', '\xe0'), ('\xc1', '\xe1'),
- ('\xc2', '\xe2'), ('\xc3', '\xe3'),
- ('\xc4', '\xe4'), ('\xc5', '\xe5'),
- ('\xc6', '\xe6'), ('\xc7', '\xe7'),
- ('\xc8', '\xe8'), ('\xc9', '\xe9'),
- ('\xca', '\xea'), ('\xcb', '\xeb'),
- ('\xcc', '\xec'), ('\xcd', '\xed'),
- ('\xce', '\xee'), ('\xcf', '\xef'),
- ('\xd0', '\xf0'), ('\xd1', '\xf1'),
- ('\xd2', '\xf2'), ('\xd3', '\xf3'),
- ('\xd4', '\xf4'), ('\xd5', '\xf5'),
- ('\xd6', '\xf6'), ('\xd8', '\xf8'),
- ('\xd9', '\xf9'), ('\xda', '\xfa'),
- ('\xdb', '\xfb'), ('\xdc', '\xfc'),
- ('\xdd', '\xfd'), ('\xde', '\xfe'),
- ('\u0100', '\u0101'), ('\u0102', '\u0103'),
- ('\u0104', '\u0105'), ('\u0106', '\u0107'),
- ('\u0108', '\u0109'), ('\u010a', '\u010b'),
- ('\u010c', '\u010d'), ('\u010e', '\u010f'),
- ('\u0110', '\u0111'), ('\u0112', '\u0113'),
- ('\u0114', '\u0115'), ('\u0116', '\u0117'),
- ('\u0118', '\u0119'), ('\u011a', '\u011b'),
- ('\u011c', '\u011d'), ('\u011e', '\u011f'),
- ('\u0120', '\u0121'), ('\u0122', '\u0123'),
- ('\u0124', '\u0125'), ('\u0126', '\u0127'),
- ('\u0128', '\u0129'), ('\u012a', '\u012b'),
- ('\u012c', '\u012d'), ('\u012e', '\u012f'),
- ('\u0130', '\x69'), ('\u0132', '\u0133'),
- ('\u0134', '\u0135'), ('\u0136', '\u0137'),
- ('\u0139', '\u013a'), ('\u013b', '\u013c'),
- ('\u013d', '\u013e'), ('\u013f', '\u0140'),
- ('\u0141', '\u0142'), ('\u0143', '\u0144'),
- ('\u0145', '\u0146'), ('\u0147', '\u0148'),
- ('\u014a', '\u014b'), ('\u014c', '\u014d'),
- ('\u014e', '\u014f'), ('\u0150', '\u0151'),
- ('\u0152', '\u0153'), ('\u0154', '\u0155'),
- ('\u0156', '\u0157'), ('\u0158', '\u0159'),
- ('\u015a', '\u015b'), ('\u015c', '\u015d'),
- ('\u015e', '\u015f'), ('\u0160', '\u0161'),
- ('\u0162', '\u0163'), ('\u0164', '\u0165'),
- ('\u0166', '\u0167'), ('\u0168', '\u0169'),
- ('\u016a', '\u016b'), ('\u016c', '\u016d'),
- ('\u016e', '\u016f'), ('\u0170', '\u0171'),
- ('\u0172', '\u0173'), ('\u0174', '\u0175'),
- ('\u0176', '\u0177'), ('\u0178', '\xff'),
- ('\u0179', '\u017a'), ('\u017b', '\u017c'),
- ('\u017d', '\u017e'), ('\u0181', '\u0253'),
- ('\u0182', '\u0183'), ('\u0184', '\u0185'),
- ('\u0186', '\u0254'), ('\u0187', '\u0188'),
- ('\u0189', '\u0256'), ('\u018a', '\u0257'),
- ('\u018b', '\u018c'), ('\u018e', '\u01dd'),
- ('\u018f', '\u0259'), ('\u0190', '\u025b'),
- ('\u0191', '\u0192'), ('\u0193', '\u0260'),
- ('\u0194', '\u0263'), ('\u0196', '\u0269'),
- ('\u0197', '\u0268'), ('\u0198', '\u0199'),
- ('\u019c', '\u026f'), ('\u019d', '\u0272'),
- ('\u019f', '\u0275'), ('\u01a0', '\u01a1'),
- ('\u01a2', '\u01a3'), ('\u01a4', '\u01a5'),
- ('\u01a6', '\u0280'), ('\u01a7', '\u01a8'),
- ('\u01a9', '\u0283'), ('\u01ac', '\u01ad'),
- ('\u01ae', '\u0288'), ('\u01af', '\u01b0'),
- ('\u01b1', '\u028a'), ('\u01b2', '\u028b'),
- ('\u01b3', '\u01b4'), ('\u01b5', '\u01b6'),
- ('\u01b7', '\u0292'), ('\u01b8', '\u01b9'),
- ('\u01bc', '\u01bd'), ('\u01c4', '\u01c6'),
- ('\u01c7', '\u01c9'), ('\u01ca', '\u01cc'),
- ('\u01cd', '\u01ce'), ('\u01cf', '\u01d0'),
- ('\u01d1', '\u01d2'), ('\u01d3', '\u01d4'),
- ('\u01d5', '\u01d6'), ('\u01d7', '\u01d8'),
- ('\u01d9', '\u01da'), ('\u01db', '\u01dc'),
- ('\u01de', '\u01df'), ('\u01e0', '\u01e1'),
- ('\u01e2', '\u01e3'), ('\u01e4', '\u01e5'),
- ('\u01e6', '\u01e7'), ('\u01e8', '\u01e9'),
- ('\u01ea', '\u01eb'), ('\u01ec', '\u01ed'),
- ('\u01ee', '\u01ef'), ('\u01f1', '\u01f3'),
- ('\u01f4', '\u01f5'), ('\u01f6', '\u0195'),
- ('\u01f7', '\u01bf'), ('\u01f8', '\u01f9'),
- ('\u01fa', '\u01fb'), ('\u01fc', '\u01fd'),
- ('\u01fe', '\u01ff'), ('\u0200', '\u0201'),
- ('\u0202', '\u0203'), ('\u0204', '\u0205'),
- ('\u0206', '\u0207'), ('\u0208', '\u0209'),
- ('\u020a', '\u020b'), ('\u020c', '\u020d'),
- ('\u020e', '\u020f'), ('\u0210', '\u0211'),
- ('\u0212', '\u0213'), ('\u0214', '\u0215'),
- ('\u0216', '\u0217'), ('\u0218', '\u0219'),
- ('\u021a', '\u021b'), ('\u021c', '\u021d'),
- ('\u021e', '\u021f'), ('\u0220', '\u019e'),
- ('\u0222', '\u0223'), ('\u0224', '\u0225'),
- ('\u0226', '\u0227'), ('\u0228', '\u0229'),
- ('\u022a', '\u022b'), ('\u022c', '\u022d'),
- ('\u022e', '\u022f'), ('\u0230', '\u0231'),
- ('\u0232', '\u0233'), ('\u023a', '\u2c65'),
- ('\u023b', '\u023c'), ('\u023d', '\u019a'),
- ('\u023e', '\u2c66'), ('\u0241', '\u0242'),
- ('\u0243', '\u0180'), ('\u0244', '\u0289'),
- ('\u0245', '\u028c'), ('\u0246', '\u0247'),
- ('\u0248', '\u0249'), ('\u024a', '\u024b'),
- ('\u024c', '\u024d'), ('\u024e', '\u024f'),
- ('\u0370', '\u0371'), ('\u0372', '\u0373'),
- ('\u0376', '\u0377'), ('\u0386', '\u03ac'),
- ('\u0388', '\u03ad'), ('\u0389', '\u03ae'),
- ('\u038a', '\u03af'), ('\u038c', '\u03cc'),
- ('\u038e', '\u03cd'), ('\u038f', '\u03ce'),
- ('\u0391', '\u03b1'), ('\u0392', '\u03b2'),
- ('\u0393', '\u03b3'), ('\u0394', '\u03b4'),
- ('\u0395', '\u03b5'), ('\u0396', '\u03b6'),
- ('\u0397', '\u03b7'), ('\u0398', '\u03b8'),
- ('\u0399', '\u03b9'), ('\u039a', '\u03ba'),
- ('\u039b', '\u03bb'), ('\u039c', '\u03bc'),
- ('\u039d', '\u03bd'), ('\u039e', '\u03be'),
- ('\u039f', '\u03bf'), ('\u03a0', '\u03c0'),
- ('\u03a1', '\u03c1'), ('\u03a3', '\u03c3'),
- ('\u03a4', '\u03c4'), ('\u03a5', '\u03c5'),
- ('\u03a6', '\u03c6'), ('\u03a7', '\u03c7'),
- ('\u03a8', '\u03c8'), ('\u03a9', '\u03c9'),
- ('\u03aa', '\u03ca'), ('\u03ab', '\u03cb'),
- ('\u03cf', '\u03d7'), ('\u03d8', '\u03d9'),
- ('\u03da', '\u03db'), ('\u03dc', '\u03dd'),
- ('\u03de', '\u03df'), ('\u03e0', '\u03e1'),
- ('\u03e2', '\u03e3'), ('\u03e4', '\u03e5'),
- ('\u03e6', '\u03e7'), ('\u03e8', '\u03e9'),
- ('\u03ea', '\u03eb'), ('\u03ec', '\u03ed'),
- ('\u03ee', '\u03ef'), ('\u03f4', '\u03b8'),
- ('\u03f7', '\u03f8'), ('\u03f9', '\u03f2'),
- ('\u03fa', '\u03fb'), ('\u03fd', '\u037b'),
- ('\u03fe', '\u037c'), ('\u03ff', '\u037d'),
- ('\u0400', '\u0450'), ('\u0401', '\u0451'),
- ('\u0402', '\u0452'), ('\u0403', '\u0453'),
- ('\u0404', '\u0454'), ('\u0405', '\u0455'),
- ('\u0406', '\u0456'), ('\u0407', '\u0457'),
- ('\u0408', '\u0458'), ('\u0409', '\u0459'),
- ('\u040a', '\u045a'), ('\u040b', '\u045b'),
- ('\u040c', '\u045c'), ('\u040d', '\u045d'),
- ('\u040e', '\u045e'), ('\u040f', '\u045f'),
- ('\u0410', '\u0430'), ('\u0411', '\u0431'),
- ('\u0412', '\u0432'), ('\u0413', '\u0433'),
- ('\u0414', '\u0434'), ('\u0415', '\u0435'),
- ('\u0416', '\u0436'), ('\u0417', '\u0437'),
- ('\u0418', '\u0438'), ('\u0419', '\u0439'),
- ('\u041a', '\u043a'), ('\u041b', '\u043b'),
- ('\u041c', '\u043c'), ('\u041d', '\u043d'),
- ('\u041e', '\u043e'), ('\u041f', '\u043f'),
- ('\u0420', '\u0440'), ('\u0421', '\u0441'),
- ('\u0422', '\u0442'), ('\u0423', '\u0443'),
- ('\u0424', '\u0444'), ('\u0425', '\u0445'),
- ('\u0426', '\u0446'), ('\u0427', '\u0447'),
- ('\u0428', '\u0448'), ('\u0429', '\u0449'),
- ('\u042a', '\u044a'), ('\u042b', '\u044b'),
- ('\u042c', '\u044c'), ('\u042d', '\u044d'),
- ('\u042e', '\u044e'), ('\u042f', '\u044f'),
- ('\u0460', '\u0461'), ('\u0462', '\u0463'),
- ('\u0464', '\u0465'), ('\u0466', '\u0467'),
- ('\u0468', '\u0469'), ('\u046a', '\u046b'),
- ('\u046c', '\u046d'), ('\u046e', '\u046f'),
- ('\u0470', '\u0471'), ('\u0472', '\u0473'),
- ('\u0474', '\u0475'), ('\u0476', '\u0477'),
- ('\u0478', '\u0479'), ('\u047a', '\u047b'),
- ('\u047c', '\u047d'), ('\u047e', '\u047f'),
- ('\u0480', '\u0481'), ('\u048a', '\u048b'),
- ('\u048c', '\u048d'), ('\u048e', '\u048f'),
- ('\u0490', '\u0491'), ('\u0492', '\u0493'),
- ('\u0494', '\u0495'), ('\u0496', '\u0497'),
- ('\u0498', '\u0499'), ('\u049a', '\u049b'),
- ('\u049c', '\u049d'), ('\u049e', '\u049f'),
- ('\u04a0', '\u04a1'), ('\u04a2', '\u04a3'),
- ('\u04a4', '\u04a5'), ('\u04a6', '\u04a7'),
- ('\u04a8', '\u04a9'), ('\u04aa', '\u04ab'),
- ('\u04ac', '\u04ad'), ('\u04ae', '\u04af'),
- ('\u04b0', '\u04b1'), ('\u04b2', '\u04b3'),
- ('\u04b4', '\u04b5'), ('\u04b6', '\u04b7'),
- ('\u04b8', '\u04b9'), ('\u04ba', '\u04bb'),
- ('\u04bc', '\u04bd'), ('\u04be', '\u04bf'),
- ('\u04c0', '\u04cf'), ('\u04c1', '\u04c2'),
- ('\u04c3', '\u04c4'), ('\u04c5', '\u04c6'),
- ('\u04c7', '\u04c8'), ('\u04c9', '\u04ca'),
- ('\u04cb', '\u04cc'), ('\u04cd', '\u04ce'),
- ('\u04d0', '\u04d1'), ('\u04d2', '\u04d3'),
- ('\u04d4', '\u04d5'), ('\u04d6', '\u04d7'),
- ('\u04d8', '\u04d9'), ('\u04da', '\u04db'),
- ('\u04dc', '\u04dd'), ('\u04de', '\u04df'),
- ('\u04e0', '\u04e1'), ('\u04e2', '\u04e3'),
- ('\u04e4', '\u04e5'), ('\u04e6', '\u04e7'),
- ('\u04e8', '\u04e9'), ('\u04ea', '\u04eb'),
- ('\u04ec', '\u04ed'), ('\u04ee', '\u04ef'),
- ('\u04f0', '\u04f1'), ('\u04f2', '\u04f3'),
- ('\u04f4', '\u04f5'), ('\u04f6', '\u04f7'),
- ('\u04f8', '\u04f9'), ('\u04fa', '\u04fb'),
- ('\u04fc', '\u04fd'), ('\u04fe', '\u04ff'),
- ('\u0500', '\u0501'), ('\u0502', '\u0503'),
- ('\u0504', '\u0505'), ('\u0506', '\u0507'),
- ('\u0508', '\u0509'), ('\u050a', '\u050b'),
- ('\u050c', '\u050d'), ('\u050e', '\u050f'),
- ('\u0510', '\u0511'), ('\u0512', '\u0513'),
- ('\u0514', '\u0515'), ('\u0516', '\u0517'),
- ('\u0518', '\u0519'), ('\u051a', '\u051b'),
- ('\u051c', '\u051d'), ('\u051e', '\u051f'),
- ('\u0520', '\u0521'), ('\u0522', '\u0523'),
- ('\u0524', '\u0525'), ('\u0526', '\u0527'),
- ('\u0531', '\u0561'), ('\u0532', '\u0562'),
- ('\u0533', '\u0563'), ('\u0534', '\u0564'),
- ('\u0535', '\u0565'), ('\u0536', '\u0566'),
- ('\u0537', '\u0567'), ('\u0538', '\u0568'),
- ('\u0539', '\u0569'), ('\u053a', '\u056a'),
- ('\u053b', '\u056b'), ('\u053c', '\u056c'),
- ('\u053d', '\u056d'), ('\u053e', '\u056e'),
- ('\u053f', '\u056f'), ('\u0540', '\u0570'),
- ('\u0541', '\u0571'), ('\u0542', '\u0572'),
- ('\u0543', '\u0573'), ('\u0544', '\u0574'),
- ('\u0545', '\u0575'), ('\u0546', '\u0576'),
- ('\u0547', '\u0577'), ('\u0548', '\u0578'),
- ('\u0549', '\u0579'), ('\u054a', '\u057a'),
- ('\u054b', '\u057b'), ('\u054c', '\u057c'),
- ('\u054d', '\u057d'), ('\u054e', '\u057e'),
- ('\u054f', '\u057f'), ('\u0550', '\u0580'),
- ('\u0551', '\u0581'), ('\u0552', '\u0582'),
- ('\u0553', '\u0583'), ('\u0554', '\u0584'),
- ('\u0555', '\u0585'), ('\u0556', '\u0586'),
- ('\u10a0', '\u2d00'), ('\u10a1', '\u2d01'),
- ('\u10a2', '\u2d02'), ('\u10a3', '\u2d03'),
- ('\u10a4', '\u2d04'), ('\u10a5', '\u2d05'),
- ('\u10a6', '\u2d06'), ('\u10a7', '\u2d07'),
- ('\u10a8', '\u2d08'), ('\u10a9', '\u2d09'),
- ('\u10aa', '\u2d0a'), ('\u10ab', '\u2d0b'),
- ('\u10ac', '\u2d0c'), ('\u10ad', '\u2d0d'),
- ('\u10ae', '\u2d0e'), ('\u10af', '\u2d0f'),
- ('\u10b0', '\u2d10'), ('\u10b1', '\u2d11'),
- ('\u10b2', '\u2d12'), ('\u10b3', '\u2d13'),
- ('\u10b4', '\u2d14'), ('\u10b5', '\u2d15'),
- ('\u10b6', '\u2d16'), ('\u10b7', '\u2d17'),
- ('\u10b8', '\u2d18'), ('\u10b9', '\u2d19'),
- ('\u10ba', '\u2d1a'), ('\u10bb', '\u2d1b'),
- ('\u10bc', '\u2d1c'), ('\u10bd', '\u2d1d'),
- ('\u10be', '\u2d1e'), ('\u10bf', '\u2d1f'),
- ('\u10c0', '\u2d20'), ('\u10c1', '\u2d21'),
- ('\u10c2', '\u2d22'), ('\u10c3', '\u2d23'),
- ('\u10c4', '\u2d24'), ('\u10c5', '\u2d25'),
- ('\u10c7', '\u2d27'), ('\u10cd', '\u2d2d'),
- ('\u1e00', '\u1e01'), ('\u1e02', '\u1e03'),
- ('\u1e04', '\u1e05'), ('\u1e06', '\u1e07'),
- ('\u1e08', '\u1e09'), ('\u1e0a', '\u1e0b'),
- ('\u1e0c', '\u1e0d'), ('\u1e0e', '\u1e0f'),
- ('\u1e10', '\u1e11'), ('\u1e12', '\u1e13'),
- ('\u1e14', '\u1e15'), ('\u1e16', '\u1e17'),
- ('\u1e18', '\u1e19'), ('\u1e1a', '\u1e1b'),
- ('\u1e1c', '\u1e1d'), ('\u1e1e', '\u1e1f'),
- ('\u1e20', '\u1e21'), ('\u1e22', '\u1e23'),
- ('\u1e24', '\u1e25'), ('\u1e26', '\u1e27'),
- ('\u1e28', '\u1e29'), ('\u1e2a', '\u1e2b'),
- ('\u1e2c', '\u1e2d'), ('\u1e2e', '\u1e2f'),
- ('\u1e30', '\u1e31'), ('\u1e32', '\u1e33'),
- ('\u1e34', '\u1e35'), ('\u1e36', '\u1e37'),
- ('\u1e38', '\u1e39'), ('\u1e3a', '\u1e3b'),
- ('\u1e3c', '\u1e3d'), ('\u1e3e', '\u1e3f'),
- ('\u1e40', '\u1e41'), ('\u1e42', '\u1e43'),
- ('\u1e44', '\u1e45'), ('\u1e46', '\u1e47'),
- ('\u1e48', '\u1e49'), ('\u1e4a', '\u1e4b'),
- ('\u1e4c', '\u1e4d'), ('\u1e4e', '\u1e4f'),
- ('\u1e50', '\u1e51'), ('\u1e52', '\u1e53'),
- ('\u1e54', '\u1e55'), ('\u1e56', '\u1e57'),
- ('\u1e58', '\u1e59'), ('\u1e5a', '\u1e5b'),
- ('\u1e5c', '\u1e5d'), ('\u1e5e', '\u1e5f'),
- ('\u1e60', '\u1e61'), ('\u1e62', '\u1e63'),
- ('\u1e64', '\u1e65'), ('\u1e66', '\u1e67'),
- ('\u1e68', '\u1e69'), ('\u1e6a', '\u1e6b'),
- ('\u1e6c', '\u1e6d'), ('\u1e6e', '\u1e6f'),
- ('\u1e70', '\u1e71'), ('\u1e72', '\u1e73'),
- ('\u1e74', '\u1e75'), ('\u1e76', '\u1e77'),
- ('\u1e78', '\u1e79'), ('\u1e7a', '\u1e7b'),
- ('\u1e7c', '\u1e7d'), ('\u1e7e', '\u1e7f'),
- ('\u1e80', '\u1e81'), ('\u1e82', '\u1e83'),
- ('\u1e84', '\u1e85'), ('\u1e86', '\u1e87'),
- ('\u1e88', '\u1e89'), ('\u1e8a', '\u1e8b'),
- ('\u1e8c', '\u1e8d'), ('\u1e8e', '\u1e8f'),
- ('\u1e90', '\u1e91'), ('\u1e92', '\u1e93'),
- ('\u1e94', '\u1e95'), ('\u1e9e', '\xdf'),
- ('\u1ea0', '\u1ea1'), ('\u1ea2', '\u1ea3'),
- ('\u1ea4', '\u1ea5'), ('\u1ea6', '\u1ea7'),
- ('\u1ea8', '\u1ea9'), ('\u1eaa', '\u1eab'),
- ('\u1eac', '\u1ead'), ('\u1eae', '\u1eaf'),
- ('\u1eb0', '\u1eb1'), ('\u1eb2', '\u1eb3'),
- ('\u1eb4', '\u1eb5'), ('\u1eb6', '\u1eb7'),
- ('\u1eb8', '\u1eb9'), ('\u1eba', '\u1ebb'),
- ('\u1ebc', '\u1ebd'), ('\u1ebe', '\u1ebf'),
- ('\u1ec0', '\u1ec1'), ('\u1ec2', '\u1ec3'),
- ('\u1ec4', '\u1ec5'), ('\u1ec6', '\u1ec7'),
- ('\u1ec8', '\u1ec9'), ('\u1eca', '\u1ecb'),
- ('\u1ecc', '\u1ecd'), ('\u1ece', '\u1ecf'),
- ('\u1ed0', '\u1ed1'), ('\u1ed2', '\u1ed3'),
- ('\u1ed4', '\u1ed5'), ('\u1ed6', '\u1ed7'),
- ('\u1ed8', '\u1ed9'), ('\u1eda', '\u1edb'),
- ('\u1edc', '\u1edd'), ('\u1ede', '\u1edf'),
- ('\u1ee0', '\u1ee1'), ('\u1ee2', '\u1ee3'),
- ('\u1ee4', '\u1ee5'), ('\u1ee6', '\u1ee7'),
- ('\u1ee8', '\u1ee9'), ('\u1eea', '\u1eeb'),
- ('\u1eec', '\u1eed'), ('\u1eee', '\u1eef'),
- ('\u1ef0', '\u1ef1'), ('\u1ef2', '\u1ef3'),
- ('\u1ef4', '\u1ef5'), ('\u1ef6', '\u1ef7'),
- ('\u1ef8', '\u1ef9'), ('\u1efa', '\u1efb'),
- ('\u1efc', '\u1efd'), ('\u1efe', '\u1eff'),
- ('\u1f08', '\u1f00'), ('\u1f09', '\u1f01'),
- ('\u1f0a', '\u1f02'), ('\u1f0b', '\u1f03'),
- ('\u1f0c', '\u1f04'), ('\u1f0d', '\u1f05'),
- ('\u1f0e', '\u1f06'), ('\u1f0f', '\u1f07'),
- ('\u1f18', '\u1f10'), ('\u1f19', '\u1f11'),
- ('\u1f1a', '\u1f12'), ('\u1f1b', '\u1f13'),
- ('\u1f1c', '\u1f14'), ('\u1f1d', '\u1f15'),
- ('\u1f28', '\u1f20'), ('\u1f29', '\u1f21'),
- ('\u1f2a', '\u1f22'), ('\u1f2b', '\u1f23'),
- ('\u1f2c', '\u1f24'), ('\u1f2d', '\u1f25'),
- ('\u1f2e', '\u1f26'), ('\u1f2f', '\u1f27'),
- ('\u1f38', '\u1f30'), ('\u1f39', '\u1f31'),
- ('\u1f3a', '\u1f32'), ('\u1f3b', '\u1f33'),
- ('\u1f3c', '\u1f34'), ('\u1f3d', '\u1f35'),
- ('\u1f3e', '\u1f36'), ('\u1f3f', '\u1f37'),
- ('\u1f48', '\u1f40'), ('\u1f49', '\u1f41'),
- ('\u1f4a', '\u1f42'), ('\u1f4b', '\u1f43'),
- ('\u1f4c', '\u1f44'), ('\u1f4d', '\u1f45'),
- ('\u1f59', '\u1f51'), ('\u1f5b', '\u1f53'),
- ('\u1f5d', '\u1f55'), ('\u1f5f', '\u1f57'),
- ('\u1f68', '\u1f60'), ('\u1f69', '\u1f61'),
- ('\u1f6a', '\u1f62'), ('\u1f6b', '\u1f63'),
- ('\u1f6c', '\u1f64'), ('\u1f6d', '\u1f65'),
- ('\u1f6e', '\u1f66'), ('\u1f6f', '\u1f67'),
- ('\u1fb8', '\u1fb0'), ('\u1fb9', '\u1fb1'),
- ('\u1fba', '\u1f70'), ('\u1fbb', '\u1f71'),
- ('\u1fc8', '\u1f72'), ('\u1fc9', '\u1f73'),
- ('\u1fca', '\u1f74'), ('\u1fcb', '\u1f75'),
- ('\u1fd8', '\u1fd0'), ('\u1fd9', '\u1fd1'),
- ('\u1fda', '\u1f76'), ('\u1fdb', '\u1f77'),
- ('\u1fe8', '\u1fe0'), ('\u1fe9', '\u1fe1'),
- ('\u1fea', '\u1f7a'), ('\u1feb', '\u1f7b'),
- ('\u1fec', '\u1fe5'), ('\u1ff8', '\u1f78'),
- ('\u1ff9', '\u1f79'), ('\u1ffa', '\u1f7c'),
- ('\u1ffb', '\u1f7d'), ('\u2126', '\u03c9'),
- ('\u212a', '\x6b'), ('\u212b', '\xe5'),
- ('\u2132', '\u214e'), ('\u2183', '\u2184'),
- ('\u2c00', '\u2c30'), ('\u2c01', '\u2c31'),
- ('\u2c02', '\u2c32'), ('\u2c03', '\u2c33'),
- ('\u2c04', '\u2c34'), ('\u2c05', '\u2c35'),
- ('\u2c06', '\u2c36'), ('\u2c07', '\u2c37'),
- ('\u2c08', '\u2c38'), ('\u2c09', '\u2c39'),
- ('\u2c0a', '\u2c3a'), ('\u2c0b', '\u2c3b'),
- ('\u2c0c', '\u2c3c'), ('\u2c0d', '\u2c3d'),
- ('\u2c0e', '\u2c3e'), ('\u2c0f', '\u2c3f'),
- ('\u2c10', '\u2c40'), ('\u2c11', '\u2c41'),
- ('\u2c12', '\u2c42'), ('\u2c13', '\u2c43'),
- ('\u2c14', '\u2c44'), ('\u2c15', '\u2c45'),
- ('\u2c16', '\u2c46'), ('\u2c17', '\u2c47'),
- ('\u2c18', '\u2c48'), ('\u2c19', '\u2c49'),
- ('\u2c1a', '\u2c4a'), ('\u2c1b', '\u2c4b'),
- ('\u2c1c', '\u2c4c'), ('\u2c1d', '\u2c4d'),
- ('\u2c1e', '\u2c4e'), ('\u2c1f', '\u2c4f'),
- ('\u2c20', '\u2c50'), ('\u2c21', '\u2c51'),
- ('\u2c22', '\u2c52'), ('\u2c23', '\u2c53'),
- ('\u2c24', '\u2c54'), ('\u2c25', '\u2c55'),
- ('\u2c26', '\u2c56'), ('\u2c27', '\u2c57'),
- ('\u2c28', '\u2c58'), ('\u2c29', '\u2c59'),
- ('\u2c2a', '\u2c5a'), ('\u2c2b', '\u2c5b'),
- ('\u2c2c', '\u2c5c'), ('\u2c2d', '\u2c5d'),
- ('\u2c2e', '\u2c5e'), ('\u2c60', '\u2c61'),
- ('\u2c62', '\u026b'), ('\u2c63', '\u1d7d'),
- ('\u2c64', '\u027d'), ('\u2c67', '\u2c68'),
- ('\u2c69', '\u2c6a'), ('\u2c6b', '\u2c6c'),
- ('\u2c6d', '\u0251'), ('\u2c6e', '\u0271'),
- ('\u2c6f', '\u0250'), ('\u2c70', '\u0252'),
- ('\u2c72', '\u2c73'), ('\u2c75', '\u2c76'),
- ('\u2c7e', '\u023f'), ('\u2c7f', '\u0240'),
- ('\u2c80', '\u2c81'), ('\u2c82', '\u2c83'),
- ('\u2c84', '\u2c85'), ('\u2c86', '\u2c87'),
- ('\u2c88', '\u2c89'), ('\u2c8a', '\u2c8b'),
- ('\u2c8c', '\u2c8d'), ('\u2c8e', '\u2c8f'),
- ('\u2c90', '\u2c91'), ('\u2c92', '\u2c93'),
- ('\u2c94', '\u2c95'), ('\u2c96', '\u2c97'),
- ('\u2c98', '\u2c99'), ('\u2c9a', '\u2c9b'),
- ('\u2c9c', '\u2c9d'), ('\u2c9e', '\u2c9f'),
- ('\u2ca0', '\u2ca1'), ('\u2ca2', '\u2ca3'),
- ('\u2ca4', '\u2ca5'), ('\u2ca6', '\u2ca7'),
- ('\u2ca8', '\u2ca9'), ('\u2caa', '\u2cab'),
- ('\u2cac', '\u2cad'), ('\u2cae', '\u2caf'),
- ('\u2cb0', '\u2cb1'), ('\u2cb2', '\u2cb3'),
- ('\u2cb4', '\u2cb5'), ('\u2cb6', '\u2cb7'),
- ('\u2cb8', '\u2cb9'), ('\u2cba', '\u2cbb'),
- ('\u2cbc', '\u2cbd'), ('\u2cbe', '\u2cbf'),
- ('\u2cc0', '\u2cc1'), ('\u2cc2', '\u2cc3'),
- ('\u2cc4', '\u2cc5'), ('\u2cc6', '\u2cc7'),
- ('\u2cc8', '\u2cc9'), ('\u2cca', '\u2ccb'),
- ('\u2ccc', '\u2ccd'), ('\u2cce', '\u2ccf'),
- ('\u2cd0', '\u2cd1'), ('\u2cd2', '\u2cd3'),
- ('\u2cd4', '\u2cd5'), ('\u2cd6', '\u2cd7'),
- ('\u2cd8', '\u2cd9'), ('\u2cda', '\u2cdb'),
- ('\u2cdc', '\u2cdd'), ('\u2cde', '\u2cdf'),
- ('\u2ce0', '\u2ce1'), ('\u2ce2', '\u2ce3'),
- ('\u2ceb', '\u2cec'), ('\u2ced', '\u2cee'),
- ('\u2cf2', '\u2cf3'), ('\ua640', '\ua641'),
- ('\ua642', '\ua643'), ('\ua644', '\ua645'),
- ('\ua646', '\ua647'), ('\ua648', '\ua649'),
- ('\ua64a', '\ua64b'), ('\ua64c', '\ua64d'),
- ('\ua64e', '\ua64f'), ('\ua650', '\ua651'),
- ('\ua652', '\ua653'), ('\ua654', '\ua655'),
- ('\ua656', '\ua657'), ('\ua658', '\ua659'),
- ('\ua65a', '\ua65b'), ('\ua65c', '\ua65d'),
- ('\ua65e', '\ua65f'), ('\ua660', '\ua661'),
- ('\ua662', '\ua663'), ('\ua664', '\ua665'),
- ('\ua666', '\ua667'), ('\ua668', '\ua669'),
- ('\ua66a', '\ua66b'), ('\ua66c', '\ua66d'),
- ('\ua680', '\ua681'), ('\ua682', '\ua683'),
- ('\ua684', '\ua685'), ('\ua686', '\ua687'),
- ('\ua688', '\ua689'), ('\ua68a', '\ua68b'),
- ('\ua68c', '\ua68d'), ('\ua68e', '\ua68f'),
- ('\ua690', '\ua691'), ('\ua692', '\ua693'),
- ('\ua694', '\ua695'), ('\ua696', '\ua697'),
- ('\ua722', '\ua723'), ('\ua724', '\ua725'),
- ('\ua726', '\ua727'), ('\ua728', '\ua729'),
- ('\ua72a', '\ua72b'), ('\ua72c', '\ua72d'),
- ('\ua72e', '\ua72f'), ('\ua732', '\ua733'),
- ('\ua734', '\ua735'), ('\ua736', '\ua737'),
- ('\ua738', '\ua739'), ('\ua73a', '\ua73b'),
- ('\ua73c', '\ua73d'), ('\ua73e', '\ua73f'),
- ('\ua740', '\ua741'), ('\ua742', '\ua743'),
- ('\ua744', '\ua745'), ('\ua746', '\ua747'),
- ('\ua748', '\ua749'), ('\ua74a', '\ua74b'),
- ('\ua74c', '\ua74d'), ('\ua74e', '\ua74f'),
- ('\ua750', '\ua751'), ('\ua752', '\ua753'),
- ('\ua754', '\ua755'), ('\ua756', '\ua757'),
- ('\ua758', '\ua759'), ('\ua75a', '\ua75b'),
- ('\ua75c', '\ua75d'), ('\ua75e', '\ua75f'),
- ('\ua760', '\ua761'), ('\ua762', '\ua763'),
- ('\ua764', '\ua765'), ('\ua766', '\ua767'),
- ('\ua768', '\ua769'), ('\ua76a', '\ua76b'),
- ('\ua76c', '\ua76d'), ('\ua76e', '\ua76f'),
- ('\ua779', '\ua77a'), ('\ua77b', '\ua77c'),
- ('\ua77d', '\u1d79'), ('\ua77e', '\ua77f'),
- ('\ua780', '\ua781'), ('\ua782', '\ua783'),
- ('\ua784', '\ua785'), ('\ua786', '\ua787'),
- ('\ua78b', '\ua78c'), ('\ua78d', '\u0265'),
- ('\ua790', '\ua791'), ('\ua792', '\ua793'),
- ('\ua7a0', '\ua7a1'), ('\ua7a2', '\ua7a3'),
- ('\ua7a4', '\ua7a5'), ('\ua7a6', '\ua7a7'),
- ('\ua7a8', '\ua7a9'), ('\ua7aa', '\u0266'),
- ('\uff21', '\uff41'), ('\uff22', '\uff42'),
- ('\uff23', '\uff43'), ('\uff24', '\uff44'),
- ('\uff25', '\uff45'), ('\uff26', '\uff46'),
- ('\uff27', '\uff47'), ('\uff28', '\uff48'),
- ('\uff29', '\uff49'), ('\uff2a', '\uff4a'),
- ('\uff2b', '\uff4b'), ('\uff2c', '\uff4c'),
- ('\uff2d', '\uff4d'), ('\uff2e', '\uff4e'),
- ('\uff2f', '\uff4f'), ('\uff30', '\uff50'),
- ('\uff31', '\uff51'), ('\uff32', '\uff52'),
- ('\uff33', '\uff53'), ('\uff34', '\uff54'),
- ('\uff35', '\uff55'), ('\uff36', '\uff56'),
- ('\uff37', '\uff57'), ('\uff38', '\uff58'),
- ('\uff39', '\uff59'), ('\uff3a', '\uff5a'),
- ('\U00010400', '\U00010428'), ('\U00010401', '\U00010429'),
- ('\U00010402', '\U0001042a'), ('\U00010403', '\U0001042b'),
- ('\U00010404', '\U0001042c'), ('\U00010405', '\U0001042d'),
- ('\U00010406', '\U0001042e'), ('\U00010407', '\U0001042f'),
- ('\U00010408', '\U00010430'), ('\U00010409', '\U00010431'),
- ('\U0001040a', '\U00010432'), ('\U0001040b', '\U00010433'),
- ('\U0001040c', '\U00010434'), ('\U0001040d', '\U00010435'),
- ('\U0001040e', '\U00010436'), ('\U0001040f', '\U00010437'),
- ('\U00010410', '\U00010438'), ('\U00010411', '\U00010439'),
- ('\U00010412', '\U0001043a'), ('\U00010413', '\U0001043b'),
- ('\U00010414', '\U0001043c'), ('\U00010415', '\U0001043d'),
- ('\U00010416', '\U0001043e'), ('\U00010417', '\U0001043f'),
- ('\U00010418', '\U00010440'), ('\U00010419', '\U00010441'),
- ('\U0001041a', '\U00010442'), ('\U0001041b', '\U00010443'),
- ('\U0001041c', '\U00010444'), ('\U0001041d', '\U00010445'),
- ('\U0001041e', '\U00010446'), ('\U0001041f', '\U00010447'),
- ('\U00010420', '\U00010448'), ('\U00010421', '\U00010449'),
- ('\U00010422', '\U0001044a'), ('\U00010423', '\U0001044b'),
- ('\U00010424', '\U0001044c'), ('\U00010425', '\U0001044d'),
- ('\U00010426', '\U0001044e'), ('\U00010427', '\U0001044f')
- ];
-
- static LlLu_table : &'static [(char, char)] = &[
- ('\x61', '\x41'), ('\x62', '\x42'),
- ('\x63', '\x43'), ('\x64', '\x44'),
- ('\x65', '\x45'), ('\x66', '\x46'),
- ('\x67', '\x47'), ('\x68', '\x48'),
- ('\x69', '\x49'), ('\x6a', '\x4a'),
- ('\x6b', '\x4b'), ('\x6c', '\x4c'),
- ('\x6d', '\x4d'), ('\x6e', '\x4e'),
- ('\x6f', '\x4f'), ('\x70', '\x50'),
- ('\x71', '\x51'), ('\x72', '\x52'),
- ('\x73', '\x53'), ('\x74', '\x54'),
- ('\x75', '\x55'), ('\x76', '\x56'),
- ('\x77', '\x57'), ('\x78', '\x58'),
- ('\x79', '\x59'), ('\x7a', '\x5a'),
- ('\xb5', '\u039c'), ('\xe0', '\xc0'),
- ('\xe1', '\xc1'), ('\xe2', '\xc2'),
- ('\xe3', '\xc3'), ('\xe4', '\xc4'),
- ('\xe5', '\xc5'), ('\xe6', '\xc6'),
- ('\xe7', '\xc7'), ('\xe8', '\xc8'),
- ('\xe9', '\xc9'), ('\xea', '\xca'),
- ('\xeb', '\xcb'), ('\xec', '\xcc'),
- ('\xed', '\xcd'), ('\xee', '\xce'),
- ('\xef', '\xcf'), ('\xf0', '\xd0'),
- ('\xf1', '\xd1'), ('\xf2', '\xd2'),
- ('\xf3', '\xd3'), ('\xf4', '\xd4'),
- ('\xf5', '\xd5'), ('\xf6', '\xd6'),
- ('\xf8', '\xd8'), ('\xf9', '\xd9'),
- ('\xfa', '\xda'), ('\xfb', '\xdb'),
- ('\xfc', '\xdc'), ('\xfd', '\xdd'),
- ('\xfe', '\xde'), ('\xff', '\u0178'),
- ('\u0101', '\u0100'), ('\u0103', '\u0102'),
- ('\u0105', '\u0104'), ('\u0107', '\u0106'),
- ('\u0109', '\u0108'), ('\u010b', '\u010a'),
- ('\u010d', '\u010c'), ('\u010f', '\u010e'),
- ('\u0111', '\u0110'), ('\u0113', '\u0112'),
- ('\u0115', '\u0114'), ('\u0117', '\u0116'),
- ('\u0119', '\u0118'), ('\u011b', '\u011a'),
- ('\u011d', '\u011c'), ('\u011f', '\u011e'),
- ('\u0121', '\u0120'), ('\u0123', '\u0122'),
- ('\u0125', '\u0124'), ('\u0127', '\u0126'),
- ('\u0129', '\u0128'), ('\u012b', '\u012a'),
- ('\u012d', '\u012c'), ('\u012f', '\u012e'),
- ('\u0131', '\x49'), ('\u0133', '\u0132'),
- ('\u0135', '\u0134'), ('\u0137', '\u0136'),
- ('\u013a', '\u0139'), ('\u013c', '\u013b'),
- ('\u013e', '\u013d'), ('\u0140', '\u013f'),
- ('\u0142', '\u0141'), ('\u0144', '\u0143'),
- ('\u0146', '\u0145'), ('\u0148', '\u0147'),
- ('\u014b', '\u014a'), ('\u014d', '\u014c'),
- ('\u014f', '\u014e'), ('\u0151', '\u0150'),
- ('\u0153', '\u0152'), ('\u0155', '\u0154'),
- ('\u0157', '\u0156'), ('\u0159', '\u0158'),
- ('\u015b', '\u015a'), ('\u015d', '\u015c'),
- ('\u015f', '\u015e'), ('\u0161', '\u0160'),
- ('\u0163', '\u0162'), ('\u0165', '\u0164'),
- ('\u0167', '\u0166'), ('\u0169', '\u0168'),
- ('\u016b', '\u016a'), ('\u016d', '\u016c'),
- ('\u016f', '\u016e'), ('\u0171', '\u0170'),
- ('\u0173', '\u0172'), ('\u0175', '\u0174'),
- ('\u0177', '\u0176'), ('\u017a', '\u0179'),
- ('\u017c', '\u017b'), ('\u017e', '\u017d'),
- ('\u017f', '\x53'), ('\u0180', '\u0243'),
- ('\u0183', '\u0182'), ('\u0185', '\u0184'),
- ('\u0188', '\u0187'), ('\u018c', '\u018b'),
- ('\u0192', '\u0191'), ('\u0195', '\u01f6'),
- ('\u0199', '\u0198'), ('\u019a', '\u023d'),
- ('\u019e', '\u0220'), ('\u01a1', '\u01a0'),
- ('\u01a3', '\u01a2'), ('\u01a5', '\u01a4'),
- ('\u01a8', '\u01a7'), ('\u01ad', '\u01ac'),
- ('\u01b0', '\u01af'), ('\u01b4', '\u01b3'),
- ('\u01b6', '\u01b5'), ('\u01b9', '\u01b8'),
- ('\u01bd', '\u01bc'), ('\u01bf', '\u01f7'),
- ('\u01c6', '\u01c4'), ('\u01c9', '\u01c7'),
- ('\u01cc', '\u01ca'), ('\u01ce', '\u01cd'),
- ('\u01d0', '\u01cf'), ('\u01d2', '\u01d1'),
- ('\u01d4', '\u01d3'), ('\u01d6', '\u01d5'),
- ('\u01d8', '\u01d7'), ('\u01da', '\u01d9'),
- ('\u01dc', '\u01db'), ('\u01dd', '\u018e'),
- ('\u01df', '\u01de'), ('\u01e1', '\u01e0'),
- ('\u01e3', '\u01e2'), ('\u01e5', '\u01e4'),
- ('\u01e7', '\u01e6'), ('\u01e9', '\u01e8'),
- ('\u01eb', '\u01ea'), ('\u01ed', '\u01ec'),
- ('\u01ef', '\u01ee'), ('\u01f3', '\u01f1'),
- ('\u01f5', '\u01f4'), ('\u01f9', '\u01f8'),
- ('\u01fb', '\u01fa'), ('\u01fd', '\u01fc'),
- ('\u01ff', '\u01fe'), ('\u0201', '\u0200'),
- ('\u0203', '\u0202'), ('\u0205', '\u0204'),
- ('\u0207', '\u0206'), ('\u0209', '\u0208'),
- ('\u020b', '\u020a'), ('\u020d', '\u020c'),
- ('\u020f', '\u020e'), ('\u0211', '\u0210'),
- ('\u0213', '\u0212'), ('\u0215', '\u0214'),
- ('\u0217', '\u0216'), ('\u0219', '\u0218'),
- ('\u021b', '\u021a'), ('\u021d', '\u021c'),
- ('\u021f', '\u021e'), ('\u0223', '\u0222'),
- ('\u0225', '\u0224'), ('\u0227', '\u0226'),
- ('\u0229', '\u0228'), ('\u022b', '\u022a'),
- ('\u022d', '\u022c'), ('\u022f', '\u022e'),
- ('\u0231', '\u0230'), ('\u0233', '\u0232'),
- ('\u023c', '\u023b'), ('\u023f', '\u2c7e'),
- ('\u0240', '\u2c7f'), ('\u0242', '\u0241'),
- ('\u0247', '\u0246'), ('\u0249', '\u0248'),
- ('\u024b', '\u024a'), ('\u024d', '\u024c'),
- ('\u024f', '\u024e'), ('\u0250', '\u2c6f'),
- ('\u0251', '\u2c6d'), ('\u0252', '\u2c70'),
- ('\u0253', '\u0181'), ('\u0254', '\u0186'),
- ('\u0256', '\u0189'), ('\u0257', '\u018a'),
- ('\u0259', '\u018f'), ('\u025b', '\u0190'),
- ('\u0260', '\u0193'), ('\u0263', '\u0194'),
- ('\u0265', '\ua78d'), ('\u0266', '\ua7aa'),
- ('\u0268', '\u0197'), ('\u0269', '\u0196'),
- ('\u026b', '\u2c62'), ('\u026f', '\u019c'),
- ('\u0271', '\u2c6e'), ('\u0272', '\u019d'),
- ('\u0275', '\u019f'), ('\u027d', '\u2c64'),
- ('\u0280', '\u01a6'), ('\u0283', '\u01a9'),
- ('\u0288', '\u01ae'), ('\u0289', '\u0244'),
- ('\u028a', '\u01b1'), ('\u028b', '\u01b2'),
- ('\u028c', '\u0245'), ('\u0292', '\u01b7'),
- ('\u0371', '\u0370'), ('\u0373', '\u0372'),
- ('\u0377', '\u0376'), ('\u037b', '\u03fd'),
- ('\u037c', '\u03fe'), ('\u037d', '\u03ff'),
- ('\u03ac', '\u0386'), ('\u03ad', '\u0388'),
- ('\u03ae', '\u0389'), ('\u03af', '\u038a'),
- ('\u03b1', '\u0391'), ('\u03b2', '\u0392'),
- ('\u03b3', '\u0393'), ('\u03b4', '\u0394'),
- ('\u03b5', '\u0395'), ('\u03b6', '\u0396'),
- ('\u03b7', '\u0397'), ('\u03b8', '\u0398'),
- ('\u03b9', '\u0399'), ('\u03ba', '\u039a'),
- ('\u03bb', '\u039b'), ('\u03bc', '\u039c'),
- ('\u03bd', '\u039d'), ('\u03be', '\u039e'),
- ('\u03bf', '\u039f'), ('\u03c0', '\u03a0'),
- ('\u03c1', '\u03a1'), ('\u03c2', '\u03a3'),
- ('\u03c3', '\u03a3'), ('\u03c4', '\u03a4'),
- ('\u03c5', '\u03a5'), ('\u03c6', '\u03a6'),
- ('\u03c7', '\u03a7'), ('\u03c8', '\u03a8'),
- ('\u03c9', '\u03a9'), ('\u03ca', '\u03aa'),
- ('\u03cb', '\u03ab'), ('\u03cc', '\u038c'),
- ('\u03cd', '\u038e'), ('\u03ce', '\u038f'),
- ('\u03d0', '\u0392'), ('\u03d1', '\u0398'),
- ('\u03d5', '\u03a6'), ('\u03d6', '\u03a0'),
- ('\u03d7', '\u03cf'), ('\u03d9', '\u03d8'),
- ('\u03db', '\u03da'), ('\u03dd', '\u03dc'),
- ('\u03df', '\u03de'), ('\u03e1', '\u03e0'),
- ('\u03e3', '\u03e2'), ('\u03e5', '\u03e4'),
- ('\u03e7', '\u03e6'), ('\u03e9', '\u03e8'),
- ('\u03eb', '\u03ea'), ('\u03ed', '\u03ec'),
- ('\u03ef', '\u03ee'), ('\u03f0', '\u039a'),
- ('\u03f1', '\u03a1'), ('\u03f2', '\u03f9'),
- ('\u03f5', '\u0395'), ('\u03f8', '\u03f7'),
- ('\u03fb', '\u03fa'), ('\u0430', '\u0410'),
- ('\u0431', '\u0411'), ('\u0432', '\u0412'),
- ('\u0433', '\u0413'), ('\u0434', '\u0414'),
- ('\u0435', '\u0415'), ('\u0436', '\u0416'),
- ('\u0437', '\u0417'), ('\u0438', '\u0418'),
- ('\u0439', '\u0419'), ('\u043a', '\u041a'),
- ('\u043b', '\u041b'), ('\u043c', '\u041c'),
- ('\u043d', '\u041d'), ('\u043e', '\u041e'),
- ('\u043f', '\u041f'), ('\u0440', '\u0420'),
- ('\u0441', '\u0421'), ('\u0442', '\u0422'),
- ('\u0443', '\u0423'), ('\u0444', '\u0424'),
- ('\u0445', '\u0425'), ('\u0446', '\u0426'),
- ('\u0447', '\u0427'), ('\u0448', '\u0428'),
- ('\u0449', '\u0429'), ('\u044a', '\u042a'),
- ('\u044b', '\u042b'), ('\u044c', '\u042c'),
- ('\u044d', '\u042d'), ('\u044e', '\u042e'),
- ('\u044f', '\u042f'), ('\u0450', '\u0400'),
- ('\u0451', '\u0401'), ('\u0452', '\u0402'),
- ('\u0453', '\u0403'), ('\u0454', '\u0404'),
- ('\u0455', '\u0405'), ('\u0456', '\u0406'),
- ('\u0457', '\u0407'), ('\u0458', '\u0408'),
- ('\u0459', '\u0409'), ('\u045a', '\u040a'),
- ('\u045b', '\u040b'), ('\u045c', '\u040c'),
- ('\u045d', '\u040d'), ('\u045e', '\u040e'),
- ('\u045f', '\u040f'), ('\u0461', '\u0460'),
- ('\u0463', '\u0462'), ('\u0465', '\u0464'),
- ('\u0467', '\u0466'), ('\u0469', '\u0468'),
- ('\u046b', '\u046a'), ('\u046d', '\u046c'),
- ('\u046f', '\u046e'), ('\u0471', '\u0470'),
- ('\u0473', '\u0472'), ('\u0475', '\u0474'),
- ('\u0477', '\u0476'), ('\u0479', '\u0478'),
- ('\u047b', '\u047a'), ('\u047d', '\u047c'),
- ('\u047f', '\u047e'), ('\u0481', '\u0480'),
- ('\u048b', '\u048a'), ('\u048d', '\u048c'),
- ('\u048f', '\u048e'), ('\u0491', '\u0490'),
- ('\u0493', '\u0492'), ('\u0495', '\u0494'),
- ('\u0497', '\u0496'), ('\u0499', '\u0498'),
- ('\u049b', '\u049a'), ('\u049d', '\u049c'),
- ('\u049f', '\u049e'), ('\u04a1', '\u04a0'),
- ('\u04a3', '\u04a2'), ('\u04a5', '\u04a4'),
- ('\u04a7', '\u04a6'), ('\u04a9', '\u04a8'),
- ('\u04ab', '\u04aa'), ('\u04ad', '\u04ac'),
- ('\u04af', '\u04ae'), ('\u04b1', '\u04b0'),
- ('\u04b3', '\u04b2'), ('\u04b5', '\u04b4'),
- ('\u04b7', '\u04b6'), ('\u04b9', '\u04b8'),
- ('\u04bb', '\u04ba'), ('\u04bd', '\u04bc'),
- ('\u04bf', '\u04be'), ('\u04c2', '\u04c1'),
- ('\u04c4', '\u04c3'), ('\u04c6', '\u04c5'),
- ('\u04c8', '\u04c7'), ('\u04ca', '\u04c9'),
- ('\u04cc', '\u04cb'), ('\u04ce', '\u04cd'),
- ('\u04cf', '\u04c0'), ('\u04d1', '\u04d0'),
- ('\u04d3', '\u04d2'), ('\u04d5', '\u04d4'),
- ('\u04d7', '\u04d6'), ('\u04d9', '\u04d8'),
- ('\u04db', '\u04da'), ('\u04dd', '\u04dc'),
- ('\u04df', '\u04de'), ('\u04e1', '\u04e0'),
- ('\u04e3', '\u04e2'), ('\u04e5', '\u04e4'),
- ('\u04e7', '\u04e6'), ('\u04e9', '\u04e8'),
- ('\u04eb', '\u04ea'), ('\u04ed', '\u04ec'),
- ('\u04ef', '\u04ee'), ('\u04f1', '\u04f0'),
- ('\u04f3', '\u04f2'), ('\u04f5', '\u04f4'),
- ('\u04f7', '\u04f6'), ('\u04f9', '\u04f8'),
- ('\u04fb', '\u04fa'), ('\u04fd', '\u04fc'),
- ('\u04ff', '\u04fe'), ('\u0501', '\u0500'),
- ('\u0503', '\u0502'), ('\u0505', '\u0504'),
- ('\u0507', '\u0506'), ('\u0509', '\u0508'),
- ('\u050b', '\u050a'), ('\u050d', '\u050c'),
- ('\u050f', '\u050e'), ('\u0511', '\u0510'),
- ('\u0513', '\u0512'), ('\u0515', '\u0514'),
- ('\u0517', '\u0516'), ('\u0519', '\u0518'),
- ('\u051b', '\u051a'), ('\u051d', '\u051c'),
- ('\u051f', '\u051e'), ('\u0521', '\u0520'),
- ('\u0523', '\u0522'), ('\u0525', '\u0524'),
- ('\u0527', '\u0526'), ('\u0561', '\u0531'),
- ('\u0562', '\u0532'), ('\u0563', '\u0533'),
- ('\u0564', '\u0534'), ('\u0565', '\u0535'),
- ('\u0566', '\u0536'), ('\u0567', '\u0537'),
- ('\u0568', '\u0538'), ('\u0569', '\u0539'),
- ('\u056a', '\u053a'), ('\u056b', '\u053b'),
- ('\u056c', '\u053c'), ('\u056d', '\u053d'),
- ('\u056e', '\u053e'), ('\u056f', '\u053f'),
- ('\u0570', '\u0540'), ('\u0571', '\u0541'),
- ('\u0572', '\u0542'), ('\u0573', '\u0543'),
- ('\u0574', '\u0544'), ('\u0575', '\u0545'),
- ('\u0576', '\u0546'), ('\u0577', '\u0547'),
- ('\u0578', '\u0548'), ('\u0579', '\u0549'),
- ('\u057a', '\u054a'), ('\u057b', '\u054b'),
- ('\u057c', '\u054c'), ('\u057d', '\u054d'),
- ('\u057e', '\u054e'), ('\u057f', '\u054f'),
- ('\u0580', '\u0550'), ('\u0581', '\u0551'),
- ('\u0582', '\u0552'), ('\u0583', '\u0553'),
- ('\u0584', '\u0554'), ('\u0585', '\u0555'),
- ('\u0586', '\u0556'), ('\u1d79', '\ua77d'),
- ('\u1d7d', '\u2c63'), ('\u1e01', '\u1e00'),
- ('\u1e03', '\u1e02'), ('\u1e05', '\u1e04'),
- ('\u1e07', '\u1e06'), ('\u1e09', '\u1e08'),
- ('\u1e0b', '\u1e0a'), ('\u1e0d', '\u1e0c'),
- ('\u1e0f', '\u1e0e'), ('\u1e11', '\u1e10'),
- ('\u1e13', '\u1e12'), ('\u1e15', '\u1e14'),
- ('\u1e17', '\u1e16'), ('\u1e19', '\u1e18'),
- ('\u1e1b', '\u1e1a'), ('\u1e1d', '\u1e1c'),
- ('\u1e1f', '\u1e1e'), ('\u1e21', '\u1e20'),
- ('\u1e23', '\u1e22'), ('\u1e25', '\u1e24'),
- ('\u1e27', '\u1e26'), ('\u1e29', '\u1e28'),
- ('\u1e2b', '\u1e2a'), ('\u1e2d', '\u1e2c'),
- ('\u1e2f', '\u1e2e'), ('\u1e31', '\u1e30'),
- ('\u1e33', '\u1e32'), ('\u1e35', '\u1e34'),
- ('\u1e37', '\u1e36'), ('\u1e39', '\u1e38'),
- ('\u1e3b', '\u1e3a'), ('\u1e3d', '\u1e3c'),
- ('\u1e3f', '\u1e3e'), ('\u1e41', '\u1e40'),
- ('\u1e43', '\u1e42'), ('\u1e45', '\u1e44'),
- ('\u1e47', '\u1e46'), ('\u1e49', '\u1e48'),
- ('\u1e4b', '\u1e4a'), ('\u1e4d', '\u1e4c'),
- ('\u1e4f', '\u1e4e'), ('\u1e51', '\u1e50'),
- ('\u1e53', '\u1e52'), ('\u1e55', '\u1e54'),
- ('\u1e57', '\u1e56'), ('\u1e59', '\u1e58'),
- ('\u1e5b', '\u1e5a'), ('\u1e5d', '\u1e5c'),
- ('\u1e5f', '\u1e5e'), ('\u1e61', '\u1e60'),
- ('\u1e63', '\u1e62'), ('\u1e65', '\u1e64'),
- ('\u1e67', '\u1e66'), ('\u1e69', '\u1e68'),
- ('\u1e6b', '\u1e6a'), ('\u1e6d', '\u1e6c'),
- ('\u1e6f', '\u1e6e'), ('\u1e71', '\u1e70'),
- ('\u1e73', '\u1e72'), ('\u1e75', '\u1e74'),
- ('\u1e77', '\u1e76'), ('\u1e79', '\u1e78'),
- ('\u1e7b', '\u1e7a'), ('\u1e7d', '\u1e7c'),
- ('\u1e7f', '\u1e7e'), ('\u1e81', '\u1e80'),
- ('\u1e83', '\u1e82'), ('\u1e85', '\u1e84'),
- ('\u1e87', '\u1e86'), ('\u1e89', '\u1e88'),
- ('\u1e8b', '\u1e8a'), ('\u1e8d', '\u1e8c'),
- ('\u1e8f', '\u1e8e'), ('\u1e91', '\u1e90'),
- ('\u1e93', '\u1e92'), ('\u1e95', '\u1e94'),
- ('\u1e9b', '\u1e60'), ('\u1ea1', '\u1ea0'),
- ('\u1ea3', '\u1ea2'), ('\u1ea5', '\u1ea4'),
- ('\u1ea7', '\u1ea6'), ('\u1ea9', '\u1ea8'),
- ('\u1eab', '\u1eaa'), ('\u1ead', '\u1eac'),
- ('\u1eaf', '\u1eae'), ('\u1eb1', '\u1eb0'),
- ('\u1eb3', '\u1eb2'), ('\u1eb5', '\u1eb4'),
- ('\u1eb7', '\u1eb6'), ('\u1eb9', '\u1eb8'),
- ('\u1ebb', '\u1eba'), ('\u1ebd', '\u1ebc'),
- ('\u1ebf', '\u1ebe'), ('\u1ec1', '\u1ec0'),
- ('\u1ec3', '\u1ec2'), ('\u1ec5', '\u1ec4'),
- ('\u1ec7', '\u1ec6'), ('\u1ec9', '\u1ec8'),
- ('\u1ecb', '\u1eca'), ('\u1ecd', '\u1ecc'),
- ('\u1ecf', '\u1ece'), ('\u1ed1', '\u1ed0'),
- ('\u1ed3', '\u1ed2'), ('\u1ed5', '\u1ed4'),
- ('\u1ed7', '\u1ed6'), ('\u1ed9', '\u1ed8'),
- ('\u1edb', '\u1eda'), ('\u1edd', '\u1edc'),
- ('\u1edf', '\u1ede'), ('\u1ee1', '\u1ee0'),
- ('\u1ee3', '\u1ee2'), ('\u1ee5', '\u1ee4'),
- ('\u1ee7', '\u1ee6'), ('\u1ee9', '\u1ee8'),
- ('\u1eeb', '\u1eea'), ('\u1eed', '\u1eec'),
- ('\u1eef', '\u1eee'), ('\u1ef1', '\u1ef0'),
- ('\u1ef3', '\u1ef2'), ('\u1ef5', '\u1ef4'),
- ('\u1ef7', '\u1ef6'), ('\u1ef9', '\u1ef8'),
- ('\u1efb', '\u1efa'), ('\u1efd', '\u1efc'),
- ('\u1eff', '\u1efe'), ('\u1f00', '\u1f08'),
- ('\u1f01', '\u1f09'), ('\u1f02', '\u1f0a'),
- ('\u1f03', '\u1f0b'), ('\u1f04', '\u1f0c'),
- ('\u1f05', '\u1f0d'), ('\u1f06', '\u1f0e'),
- ('\u1f07', '\u1f0f'), ('\u1f10', '\u1f18'),
- ('\u1f11', '\u1f19'), ('\u1f12', '\u1f1a'),
- ('\u1f13', '\u1f1b'), ('\u1f14', '\u1f1c'),
- ('\u1f15', '\u1f1d'), ('\u1f20', '\u1f28'),
- ('\u1f21', '\u1f29'), ('\u1f22', '\u1f2a'),
- ('\u1f23', '\u1f2b'), ('\u1f24', '\u1f2c'),
- ('\u1f25', '\u1f2d'), ('\u1f26', '\u1f2e'),
- ('\u1f27', '\u1f2f'), ('\u1f30', '\u1f38'),
- ('\u1f31', '\u1f39'), ('\u1f32', '\u1f3a'),
- ('\u1f33', '\u1f3b'), ('\u1f34', '\u1f3c'),
- ('\u1f35', '\u1f3d'), ('\u1f36', '\u1f3e'),
- ('\u1f37', '\u1f3f'), ('\u1f40', '\u1f48'),
- ('\u1f41', '\u1f49'), ('\u1f42', '\u1f4a'),
- ('\u1f43', '\u1f4b'), ('\u1f44', '\u1f4c'),
- ('\u1f45', '\u1f4d'), ('\u1f51', '\u1f59'),
- ('\u1f53', '\u1f5b'), ('\u1f55', '\u1f5d'),
- ('\u1f57', '\u1f5f'), ('\u1f60', '\u1f68'),
- ('\u1f61', '\u1f69'), ('\u1f62', '\u1f6a'),
- ('\u1f63', '\u1f6b'), ('\u1f64', '\u1f6c'),
- ('\u1f65', '\u1f6d'), ('\u1f66', '\u1f6e'),
- ('\u1f67', '\u1f6f'), ('\u1f70', '\u1fba'),
- ('\u1f71', '\u1fbb'), ('\u1f72', '\u1fc8'),
- ('\u1f73', '\u1fc9'), ('\u1f74', '\u1fca'),
- ('\u1f75', '\u1fcb'), ('\u1f76', '\u1fda'),
- ('\u1f77', '\u1fdb'), ('\u1f78', '\u1ff8'),
- ('\u1f79', '\u1ff9'), ('\u1f7a', '\u1fea'),
- ('\u1f7b', '\u1feb'), ('\u1f7c', '\u1ffa'),
- ('\u1f7d', '\u1ffb'), ('\u1f80', '\u1f88'),
- ('\u1f81', '\u1f89'), ('\u1f82', '\u1f8a'),
- ('\u1f83', '\u1f8b'), ('\u1f84', '\u1f8c'),
- ('\u1f85', '\u1f8d'), ('\u1f86', '\u1f8e'),
- ('\u1f87', '\u1f8f'), ('\u1f90', '\u1f98'),
- ('\u1f91', '\u1f99'), ('\u1f92', '\u1f9a'),
- ('\u1f93', '\u1f9b'), ('\u1f94', '\u1f9c'),
- ('\u1f95', '\u1f9d'), ('\u1f96', '\u1f9e'),
- ('\u1f97', '\u1f9f'), ('\u1fa0', '\u1fa8'),
- ('\u1fa1', '\u1fa9'), ('\u1fa2', '\u1faa'),
- ('\u1fa3', '\u1fab'), ('\u1fa4', '\u1fac'),
- ('\u1fa5', '\u1fad'), ('\u1fa6', '\u1fae'),
- ('\u1fa7', '\u1faf'), ('\u1fb0', '\u1fb8'),
- ('\u1fb1', '\u1fb9'), ('\u1fb3', '\u1fbc'),
- ('\u1fbe', '\u0399'), ('\u1fc3', '\u1fcc'),
- ('\u1fd0', '\u1fd8'), ('\u1fd1', '\u1fd9'),
- ('\u1fe0', '\u1fe8'), ('\u1fe1', '\u1fe9'),
- ('\u1fe5', '\u1fec'), ('\u1ff3', '\u1ffc'),
- ('\u214e', '\u2132'), ('\u2184', '\u2183'),
- ('\u2c30', '\u2c00'), ('\u2c31', '\u2c01'),
- ('\u2c32', '\u2c02'), ('\u2c33', '\u2c03'),
- ('\u2c34', '\u2c04'), ('\u2c35', '\u2c05'),
- ('\u2c36', '\u2c06'), ('\u2c37', '\u2c07'),
- ('\u2c38', '\u2c08'), ('\u2c39', '\u2c09'),
- ('\u2c3a', '\u2c0a'), ('\u2c3b', '\u2c0b'),
- ('\u2c3c', '\u2c0c'), ('\u2c3d', '\u2c0d'),
- ('\u2c3e', '\u2c0e'), ('\u2c3f', '\u2c0f'),
- ('\u2c40', '\u2c10'), ('\u2c41', '\u2c11'),
- ('\u2c42', '\u2c12'), ('\u2c43', '\u2c13'),
- ('\u2c44', '\u2c14'), ('\u2c45', '\u2c15'),
- ('\u2c46', '\u2c16'), ('\u2c47', '\u2c17'),
- ('\u2c48', '\u2c18'), ('\u2c49', '\u2c19'),
- ('\u2c4a', '\u2c1a'), ('\u2c4b', '\u2c1b'),
- ('\u2c4c', '\u2c1c'), ('\u2c4d', '\u2c1d'),
- ('\u2c4e', '\u2c1e'), ('\u2c4f', '\u2c1f'),
- ('\u2c50', '\u2c20'), ('\u2c51', '\u2c21'),
- ('\u2c52', '\u2c22'), ('\u2c53', '\u2c23'),
- ('\u2c54', '\u2c24'), ('\u2c55', '\u2c25'),
- ('\u2c56', '\u2c26'), ('\u2c57', '\u2c27'),
- ('\u2c58', '\u2c28'), ('\u2c59', '\u2c29'),
- ('\u2c5a', '\u2c2a'), ('\u2c5b', '\u2c2b'),
- ('\u2c5c', '\u2c2c'), ('\u2c5d', '\u2c2d'),
- ('\u2c5e', '\u2c2e'), ('\u2c61', '\u2c60'),
- ('\u2c65', '\u023a'), ('\u2c66', '\u023e'),
- ('\u2c68', '\u2c67'), ('\u2c6a', '\u2c69'),
- ('\u2c6c', '\u2c6b'), ('\u2c73', '\u2c72'),
- ('\u2c76', '\u2c75'), ('\u2c81', '\u2c80'),
- ('\u2c83', '\u2c82'), ('\u2c85', '\u2c84'),
- ('\u2c87', '\u2c86'), ('\u2c89', '\u2c88'),
- ('\u2c8b', '\u2c8a'), ('\u2c8d', '\u2c8c'),
- ('\u2c8f', '\u2c8e'), ('\u2c91', '\u2c90'),
- ('\u2c93', '\u2c92'), ('\u2c95', '\u2c94'),
- ('\u2c97', '\u2c96'), ('\u2c99', '\u2c98'),
- ('\u2c9b', '\u2c9a'), ('\u2c9d', '\u2c9c'),
- ('\u2c9f', '\u2c9e'), ('\u2ca1', '\u2ca0'),
- ('\u2ca3', '\u2ca2'), ('\u2ca5', '\u2ca4'),
- ('\u2ca7', '\u2ca6'), ('\u2ca9', '\u2ca8'),
- ('\u2cab', '\u2caa'), ('\u2cad', '\u2cac'),
- ('\u2caf', '\u2cae'), ('\u2cb1', '\u2cb0'),
- ('\u2cb3', '\u2cb2'), ('\u2cb5', '\u2cb4'),
- ('\u2cb7', '\u2cb6'), ('\u2cb9', '\u2cb8'),
- ('\u2cbb', '\u2cba'), ('\u2cbd', '\u2cbc'),
- ('\u2cbf', '\u2cbe'), ('\u2cc1', '\u2cc0'),
- ('\u2cc3', '\u2cc2'), ('\u2cc5', '\u2cc4'),
- ('\u2cc7', '\u2cc6'), ('\u2cc9', '\u2cc8'),
- ('\u2ccb', '\u2cca'), ('\u2ccd', '\u2ccc'),
- ('\u2ccf', '\u2cce'), ('\u2cd1', '\u2cd0'),
- ('\u2cd3', '\u2cd2'), ('\u2cd5', '\u2cd4'),
- ('\u2cd7', '\u2cd6'), ('\u2cd9', '\u2cd8'),
- ('\u2cdb', '\u2cda'), ('\u2cdd', '\u2cdc'),
- ('\u2cdf', '\u2cde'), ('\u2ce1', '\u2ce0'),
- ('\u2ce3', '\u2ce2'), ('\u2cec', '\u2ceb'),
- ('\u2cee', '\u2ced'), ('\u2cf3', '\u2cf2'),
- ('\u2d00', '\u10a0'), ('\u2d01', '\u10a1'),
- ('\u2d02', '\u10a2'), ('\u2d03', '\u10a3'),
- ('\u2d04', '\u10a4'), ('\u2d05', '\u10a5'),
- ('\u2d06', '\u10a6'), ('\u2d07', '\u10a7'),
- ('\u2d08', '\u10a8'), ('\u2d09', '\u10a9'),
- ('\u2d0a', '\u10aa'), ('\u2d0b', '\u10ab'),
- ('\u2d0c', '\u10ac'), ('\u2d0d', '\u10ad'),
- ('\u2d0e', '\u10ae'), ('\u2d0f', '\u10af'),
- ('\u2d10', '\u10b0'), ('\u2d11', '\u10b1'),
- ('\u2d12', '\u10b2'), ('\u2d13', '\u10b3'),
- ('\u2d14', '\u10b4'), ('\u2d15', '\u10b5'),
- ('\u2d16', '\u10b6'), ('\u2d17', '\u10b7'),
- ('\u2d18', '\u10b8'), ('\u2d19', '\u10b9'),
- ('\u2d1a', '\u10ba'), ('\u2d1b', '\u10bb'),
- ('\u2d1c', '\u10bc'), ('\u2d1d', '\u10bd'),
- ('\u2d1e', '\u10be'), ('\u2d1f', '\u10bf'),
- ('\u2d20', '\u10c0'), ('\u2d21', '\u10c1'),
- ('\u2d22', '\u10c2'), ('\u2d23', '\u10c3'),
- ('\u2d24', '\u10c4'), ('\u2d25', '\u10c5'),
- ('\u2d27', '\u10c7'), ('\u2d2d', '\u10cd'),
- ('\ua641', '\ua640'), ('\ua643', '\ua642'),
- ('\ua645', '\ua644'), ('\ua647', '\ua646'),
- ('\ua649', '\ua648'), ('\ua64b', '\ua64a'),
- ('\ua64d', '\ua64c'), ('\ua64f', '\ua64e'),
- ('\ua651', '\ua650'), ('\ua653', '\ua652'),
- ('\ua655', '\ua654'), ('\ua657', '\ua656'),
- ('\ua659', '\ua658'), ('\ua65b', '\ua65a'),
- ('\ua65d', '\ua65c'), ('\ua65f', '\ua65e'),
- ('\ua661', '\ua660'), ('\ua663', '\ua662'),
- ('\ua665', '\ua664'), ('\ua667', '\ua666'),
- ('\ua669', '\ua668'), ('\ua66b', '\ua66a'),
- ('\ua66d', '\ua66c'), ('\ua681', '\ua680'),
- ('\ua683', '\ua682'), ('\ua685', '\ua684'),
- ('\ua687', '\ua686'), ('\ua689', '\ua688'),
- ('\ua68b', '\ua68a'), ('\ua68d', '\ua68c'),
- ('\ua68f', '\ua68e'), ('\ua691', '\ua690'),
- ('\ua693', '\ua692'), ('\ua695', '\ua694'),
- ('\ua697', '\ua696'), ('\ua723', '\ua722'),
- ('\ua725', '\ua724'), ('\ua727', '\ua726'),
- ('\ua729', '\ua728'), ('\ua72b', '\ua72a'),
- ('\ua72d', '\ua72c'), ('\ua72f', '\ua72e'),
- ('\ua733', '\ua732'), ('\ua735', '\ua734'),
- ('\ua737', '\ua736'), ('\ua739', '\ua738'),
- ('\ua73b', '\ua73a'), ('\ua73d', '\ua73c'),
- ('\ua73f', '\ua73e'), ('\ua741', '\ua740'),
- ('\ua743', '\ua742'), ('\ua745', '\ua744'),
- ('\ua747', '\ua746'), ('\ua749', '\ua748'),
- ('\ua74b', '\ua74a'), ('\ua74d', '\ua74c'),
- ('\ua74f', '\ua74e'), ('\ua751', '\ua750'),
- ('\ua753', '\ua752'), ('\ua755', '\ua754'),
- ('\ua757', '\ua756'), ('\ua759', '\ua758'),
- ('\ua75b', '\ua75a'), ('\ua75d', '\ua75c'),
- ('\ua75f', '\ua75e'), ('\ua761', '\ua760'),
- ('\ua763', '\ua762'), ('\ua765', '\ua764'),
- ('\ua767', '\ua766'), ('\ua769', '\ua768'),
- ('\ua76b', '\ua76a'), ('\ua76d', '\ua76c'),
- ('\ua76f', '\ua76e'), ('\ua77a', '\ua779'),
- ('\ua77c', '\ua77b'), ('\ua77f', '\ua77e'),
- ('\ua781', '\ua780'), ('\ua783', '\ua782'),
- ('\ua785', '\ua784'), ('\ua787', '\ua786'),
- ('\ua78c', '\ua78b'), ('\ua791', '\ua790'),
- ('\ua793', '\ua792'), ('\ua7a1', '\ua7a0'),
- ('\ua7a3', '\ua7a2'), ('\ua7a5', '\ua7a4'),
- ('\ua7a7', '\ua7a6'), ('\ua7a9', '\ua7a8'),
- ('\uff41', '\uff21'), ('\uff42', '\uff22'),
- ('\uff43', '\uff23'), ('\uff44', '\uff24'),
- ('\uff45', '\uff25'), ('\uff46', '\uff26'),
- ('\uff47', '\uff27'), ('\uff48', '\uff28'),
- ('\uff49', '\uff29'), ('\uff4a', '\uff2a'),
- ('\uff4b', '\uff2b'), ('\uff4c', '\uff2c'),
- ('\uff4d', '\uff2d'), ('\uff4e', '\uff2e'),
- ('\uff4f', '\uff2f'), ('\uff50', '\uff30'),
- ('\uff51', '\uff31'), ('\uff52', '\uff32'),
- ('\uff53', '\uff33'), ('\uff54', '\uff34'),
- ('\uff55', '\uff35'), ('\uff56', '\uff36'),
- ('\uff57', '\uff37'), ('\uff58', '\uff38'),
- ('\uff59', '\uff39'), ('\uff5a', '\uff3a'),
- ('\U00010428', '\U00010400'), ('\U00010429', '\U00010401'),
- ('\U0001042a', '\U00010402'), ('\U0001042b', '\U00010403'),
- ('\U0001042c', '\U00010404'), ('\U0001042d', '\U00010405'),
- ('\U0001042e', '\U00010406'), ('\U0001042f', '\U00010407'),
- ('\U00010430', '\U00010408'), ('\U00010431', '\U00010409'),
- ('\U00010432', '\U0001040a'), ('\U00010433', '\U0001040b'),
- ('\U00010434', '\U0001040c'), ('\U00010435', '\U0001040d'),
- ('\U00010436', '\U0001040e'), ('\U00010437', '\U0001040f'),
- ('\U00010438', '\U00010410'), ('\U00010439', '\U00010411'),
- ('\U0001043a', '\U00010412'), ('\U0001043b', '\U00010413'),
- ('\U0001043c', '\U00010414'), ('\U0001043d', '\U00010415'),
- ('\U0001043e', '\U00010416'), ('\U0001043f', '\U00010417'),
- ('\U00010440', '\U00010418'), ('\U00010441', '\U00010419'),
- ('\U00010442', '\U0001041a'), ('\U00010443', '\U0001041b'),
- ('\U00010444', '\U0001041c'), ('\U00010445', '\U0001041d'),
- ('\U00010446', '\U0001041e'), ('\U00010447', '\U0001041f'),
- ('\U00010448', '\U00010420'), ('\U00010449', '\U00010421'),
- ('\U0001044a', '\U00010422'), ('\U0001044b', '\U00010423'),
- ('\U0001044c', '\U00010424'), ('\U0001044d', '\U00010425'),
- ('\U0001044e', '\U00010426'), ('\U0001044f', '\U00010427')
- ];
-
-}
check('\ua66e', [0xa66e]);
check('\U0001f4a9', [0xd83d, 0xdca9]);
}
+
+#[test]
+fn test_width() {
+ assert_eq!('\x00'.width(false),Some(0));
+ assert_eq!('\x00'.width(true),Some(0));
+
+ assert_eq!('\x0A'.width(false),None);
+ assert_eq!('\x0A'.width(true),None);
+
+ assert_eq!('w'.width(false),Some(1));
+ assert_eq!('w'.width(true),Some(1));
+
+ assert_eq!('ｈ'.width(false),Some(2));
+ assert_eq!('ｈ'.width(true),Some(2));
+
+ assert_eq!('\xAD'.width(false),Some(1));
+ assert_eq!('\xAD'.width(true),Some(1));
+
+ assert_eq!('\u1160'.width(false),Some(0));
+ assert_eq!('\u1160'.width(true),Some(0));
+
+ assert_eq!('\u00a1'.width(false),Some(1));
+ assert_eq!('\u00a1'.width(true),Some(2));
+
+ assert_eq!('\u0300'.width(false),Some(0));
+ assert_eq!('\u0300'.width(true),Some(0));
+}
//! Additionally, it is not guaranteed that functionality such as reflection
//! will persist into the future.
-#![crate_id = "debug#0.11.0"] // NOTE: remove after stage0
#![crate_name = "debug"]
#![experimental]
#![license = "MIT/ASL2"]
#![experimental]
#![feature(managed_boxes, macro_rules)]
#![allow(experimental)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
pub mod fmt;
pub mod reflect;
*/
-#![crate_id = "flate#0.11.0"] // NOTE: remove after stage0
#![crate_name = "flate"]
#![experimental]
#![crate_type = "rlib"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/")]
#![feature(phase)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#[cfg(test)] #[phase(plugin, link)] extern crate log;
//! Parsing does not happen at runtime: structures of `std::fmt::rt` are
//! generated instead.
-#![crate_id = "fmt_macros#0.11.0"] // NOTE: remove after stage0c
#![crate_name = "fmt_macros"]
#![experimental]
#![license = "MIT/ASL2"]
#![crate_type = "rlib"]
#![crate_type = "dylib"]
#![feature(macro_rules, globs)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
use std::char;
use std::str;
*/
-#![crate_id = "fourcc#0.11.0"] // NOTE: remove after stage0
#![crate_name = "fourcc"]
#![experimental]
#![crate_type = "rlib"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![feature(plugin_registrar, managed_boxes)]
//! }
//! ~~~
-#![crate_id = "getopts#0.11.0"] // NOTE: remove after stage0
#![crate_name = "getopts"]
#![experimental]
#![crate_type = "rlib"]
html_playground_url = "http://play.rust-lang.org/")]
#![feature(globs, phase)]
#![deny(missing_doc)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#[cfg(test)] extern crate debug;
#[cfg(test)] #[phase(plugin, link)] extern crate log;
*cont
};
- ss.char_indices().advance(|x| machine(&mut cont, x));
+ ss.char_indices().all(|x| machine(&mut cont, x));
// Let the automaton 'run out' by supplying trailing whitespace
while cont && match state { B | C => true, A => false } {
* `glob`/`fnmatch` functions.
*/
-#![crate_id = "glob#0.11.0"] // NOTE: remove after stage0
#![crate_name = "glob"]
#![experimental]
#![crate_type = "rlib"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/",
html_playground_url = "http://play.rust-lang.org/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
use std::cell::Cell;
use std::{cmp, os, path};
*/
-#![crate_id = "graphviz#0.11.0"] // NOTE: remove after stage0
#![crate_name = "graphviz"]
#![experimental]
#![crate_type = "rlib"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
use std::io;
use std::str;
//! possibly pinned to a particular scheduler thread:
//!
//! ```rust
+//! extern crate green;
+//! extern crate rustuv;
+//!
+//! # fn main() {
//! use std::task::TaskBuilder;
//! use green::{SchedPool, PoolConfig, GreenTaskBuilder};
//!
-//! let config = PoolConfig::new();
+//! let mut config = PoolConfig::new();
+//!
+//! // Optional: Set the event loop to be rustuv's to allow I/O to work
+//! config.event_loop_factory = rustuv::event_loop;
+//!
//! let mut pool = SchedPool::new(config);
//!
//! // Spawn tasks into the pool of schedulers
//! // Required to shut down this scheduler pool.
//! // The task will fail if `shutdown` is not called.
//! pool.shutdown();
+//! # }
//! ```
-#![crate_id = "green#0.11.0"] // NOTE: remove after stage0
#![crate_name = "green"]
#![experimental]
#![license = "MIT/ASL2"]
// NB this does *not* include globs, please keep it that way.
#![feature(macro_rules, phase, default_type_params)]
#![allow(visible_private_types, deprecated)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#[cfg(test)] #[phase(plugin, link)] extern crate log;
#[cfg(test)] extern crate rustuv;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::ptr;
use std::sync::atomics;
use std::os::{errno, page_size, MemoryMap, MapReadable, MapWritable,
- MapNonStandardFlags, MapVirtual, getenv};
+ MapNonStandardFlags, getenv};
use libc;
/// A task's stack. The name "Stack" is a vestige of segmented stacks.
pub struct Stack {
- buf: MemoryMap,
+ buf: Option<MemoryMap>,
min_size: uint,
valgrind_id: libc::c_uint,
}
// guaranteed to be aligned properly.
if !protect_last_page(&stack) {
fail!("Could not memory-protect guard page. stack={}, errno={}",
- stack.data, errno());
+ stack.data(), errno());
}
let mut stk = Stack {
- buf: stack,
+ buf: Some(stack),
min_size: size,
valgrind_id: 0
};
/// Create a 0-length stack which starts (and ends) at 0.
pub unsafe fn dummy_stack() -> Stack {
Stack {
- buf: MemoryMap { data: 0 as *mut u8, len: 0, kind: MapVirtual },
+ buf: None,
min_size: 0,
valgrind_id: 0
}
/// Point to the low end of the allocated stack
pub fn start(&self) -> *const uint {
- self.buf.data as *const uint
+ self.buf.as_ref().map(|m| m.data() as *const uint)
+ .unwrap_or(ptr::null())
}
/// Point one uint beyond the high end of the allocated stack
pub fn end(&self) -> *const uint {
- unsafe {
- self.buf.data.offset(self.buf.len as int) as *const uint
- }
+ self.buf.as_ref().map(|buf| unsafe {
+ buf.data().offset(buf.len() as int) as *const uint
+ }).unwrap_or(ptr::null())
}
}
// This may seem backwards: the start of the segment is the last page?
// Yes! The stack grows from higher addresses (the end of the allocated
// block) to lower addresses (the start of the allocated block).
- let last_page = stack.data as *mut libc::c_void;
+ let last_page = stack.data() as *mut libc::c_void;
libc::mprotect(last_page, page_size() as libc::size_t,
libc::PROT_NONE) != -1
}
fn protect_last_page(stack: &MemoryMap) -> bool {
unsafe {
// see above
- let last_page = stack.data as *mut libc::c_void;
+ let last_page = stack.data() as *mut libc::c_void;
let mut old_prot: libc::DWORD = 0;
libc::VirtualProtect(last_page, page_size() as libc::SIZE_T,
libc::PAGE_NOACCESS,
*/
-#![crate_id = "hexfloat#0.11.0"] // NOTE: remove after stage0
#![crate_name = "hexfloat"]
#![experimental]
#![crate_type = "rlib"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/")]
#![feature(plugin_registrar, managed_boxes)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
extern crate syntax;
extern crate rustc;
// except according to those terms.
#![feature(globs)]
-#![crate_id = "libc#0.11.0"] // NOTE: remove after a stage0 snap
#![crate_name = "libc"]
#![experimental]
#![no_std] // we don't need std, and we can't have std, since it doesn't exist
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/",
html_playground_url = "http://play.rust-lang.org/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
/*!
* Bindings for the C standard library and other platform libraries
*/
-#![crate_id = "log#0.11.0"] // NOTE: Remove after stage0
#![crate_name = "log"]
#![experimental]
#![license = "MIT/ASL2"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/",
html_playground_url = "http://play.rust-lang.org/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![feature(macro_rules)]
#![deny(missing_doc)]
}
#[cfg(unix)]
-fn with_envp<T>(env: Option<&[(CString, CString)]>,
+fn with_envp<T>(env: Option<&[(&CString, &CString)]>,
cb: proc(*const c_void) -> T) -> T {
// On posixy systems we can pass a char** for envp, which is a
// null-terminated array of "k=v\0" strings. Since we must create
}
#[cfg(windows)]
-fn with_envp<T>(env: Option<&[(CString, CString)]>, cb: |*mut c_void| -> T) -> T {
+fn with_envp<T>(env: Option<&[(&CString, &CString)]>, cb: |*mut c_void| -> T) -> T {
// On win32 we pass an "environment block" which is not a char**, but
// rather a concatenation of null-terminated k=v\0 sequences, with a final
// \0 to terminate.
//! }
//! ```
-#![crate_id = "native#0.11.0"] // NOTE: remove after stage0
#![crate_name = "native"]
#![experimental]
#![license = "MIT/ASL2"]
#![deny(unused_result, unused_must_use)]
#![allow(non_camel_case_types, deprecated)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![feature(default_type_params, lang_items)]
// NB this crate explicitly does *not* allow glob imports, please seriously
#![feature(macro_rules)]
-#![crate_id = "num#0.11.0"] // NOTE: remove after stage0
#![crate_name = "num"]
#![experimental]
#![crate_type = "rlib"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/",
html_playground_url = "http://play.rust-lang.org/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![allow(deprecated)] // from_str_radix
extern crate rand;
//! is not recommended to use this library directly, but rather the official
//! interface through `std::rand`.
-#![crate_id = "rand#0.11.0"] // NOTE: remove after a stage0 snap
#![crate_name = "rand"]
#![license = "MIT/ASL2"]
#![crate_type = "rlib"]
html_playground_url = "http://play.rust-lang.org/")]
#![feature(macro_rules, phase, globs)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![no_std]
#![experimental]
//!
//! ## Perl character classes (Unicode friendly)
//!
+//! These classes are based on the definitions provided in
+//! [UTS#18](http://www.unicode.org/reports/tr18/#Compatibility_Properties):
+//!
//! <pre class="rust">
-//! \d digit ([0-9] + \p{Nd})
+//! \d digit (\p{Nd})
//! \D not digit
-//! \s whitespace ([\t\n\f\r ] + \p{Z})
+//! \s whitespace (\p{White_Space})
//! \S not whitespace
-//! \w word character ([0-9A-Za-z_] + \p{L})
+//! \w word character (\p{Alphabetic} + \p{M} + \d + \p{Pc} + \p{Join_Control})
//! \W not word character
//! </pre>
//!
//! characters in the search text and `m` is the number of instructions in a
//! compiled expression.
-#![crate_id = "regex#0.11.0"] // NOTE: remove after stage0
#![crate_name = "regex"]
#![crate_type = "rlib"]
#![crate_type = "dylib"]
html_playground_url = "http://play.rust-lang.org/")]
#![feature(macro_rules, phase)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![deny(missing_doc)]
#[cfg(test)]
#[cfg(test)]
extern crate regex;
+// unicode tables for character classes are defined in libunicode
+extern crate unicode;
+
pub use parse::Error;
pub use re::{Regex, Captures, SubCaptures, SubCapturesPos};
pub use re::{FindCaptures, FindMatches};
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::char;
+use std::cmp;
+use std::fmt;
+use std::iter;
+use std::num;
+use std::str;
+
+/// Static data containing Unicode ranges for general categories and scripts.
+use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW};
+
+/// The maximum number of repetitions allowed with the `{n,m}` syntax.
+static MAX_REPEAT: uint = 1000;
+
+/// Error corresponds to something that can go wrong while parsing
+/// a regular expression.
+///
+/// (Once an expression is compiled, it is not possible to produce an error
+/// via searching, splitting or replacing.)
+pub struct Error {
+ /// The *approximate* character index of where the error occurred.
+ pub pos: uint,
+ /// A message describing the error.
+ pub msg: String,
+}
+
+impl fmt::Show for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "Regex syntax error near position {}: {}",
+ self.pos, self.msg)
+ }
+}
+
+/// Represents the abstract syntax of a regular expression.
+/// It is showable so that error messages resulting from a bug can provide
+/// useful information.
+/// It is cloneable so that expressions can be repeated for the counted
+/// repetition feature. (No other copying is done.)
+///
+/// Note that this representation prevents one from reproducing the regex as
+/// it was typed. (But it could be used to reproduce an equivalent regex.)
+#[deriving(Show, Clone)]
+pub enum Ast {
+ Nothing,
+ Literal(char, Flags),
+ Dot(Flags),
+ Class(Vec<(char, char)>, Flags),
+ Begin(Flags),
+ End(Flags),
+ WordBoundary(Flags),
+ Capture(uint, Option<String>, Box<Ast>),
+ // Represent concatenation as a flat vector to avoid blowing the
+ // stack in the compiler.
+ Cat(Vec<Ast>),
+ Alt(Box<Ast>, Box<Ast>),
+ Rep(Box<Ast>, Repeater, Greed),
+}
+
+#[deriving(Show, PartialEq, Clone)]
+pub enum Repeater {
+ ZeroOne,
+ ZeroMore,
+ OneMore,
+}
+
+#[deriving(Show, Clone)]
+pub enum Greed {
+ Greedy,
+ Ungreedy,
+}
+
+impl Greed {
+ pub fn is_greedy(&self) -> bool {
+ match *self {
+ Greedy => true,
+ _ => false,
+ }
+ }
+
+ fn swap(self, swapped: bool) -> Greed {
+ if !swapped { return self }
+ match self {
+ Greedy => Ungreedy,
+ Ungreedy => Greedy,
+ }
+ }
+}
+
+/// BuildAst is a regrettable type that represents intermediate state for
+/// constructing an abstract syntax tree. Its central purpose is to facilitate
+/// parsing groups and alternations while also maintaining a stack of flag
+/// state.
+#[deriving(Show)]
+enum BuildAst {
+ Ast(Ast),
+ Paren(Flags, uint, String), // '('
+ Bar, // '|'
+}
+
+impl BuildAst {
+ fn paren(&self) -> bool {
+ match *self {
+ Paren(_, _, _) => true,
+ _ => false,
+ }
+ }
+
+ fn flags(&self) -> Flags {
+ match *self {
+ Paren(flags, _, _) => flags,
+ _ => fail!("Cannot get flags from {}", self),
+ }
+ }
+
+ fn capture(&self) -> Option<uint> {
+ match *self {
+ Paren(_, 0, _) => None,
+ Paren(_, c, _) => Some(c),
+ _ => fail!("Cannot get capture group from {}", self),
+ }
+ }
+
+ fn capture_name(&self) -> Option<String> {
+ match *self {
+ Paren(_, 0, _) => None,
+ Paren(_, _, ref name) => {
+ if name.len() == 0 {
+ None
+ } else {
+ Some(name.clone())
+ }
+ }
+ _ => fail!("Cannot get capture name from {}", self),
+ }
+ }
+
+ fn bar(&self) -> bool {
+ match *self {
+ Bar => true,
+ _ => false,
+ }
+ }
+
+ fn unwrap(self) -> Result<Ast, Error> {
+ match self {
+ Ast(x) => Ok(x),
+ _ => fail!("Tried to unwrap non-AST item: {}", self),
+ }
+ }
+}
+
+/// Flags represents all options that can be twiddled by a user in an
+/// expression.
+pub type Flags = u8;
+
+pub static FLAG_EMPTY: u8 = 0;
+pub static FLAG_NOCASE: u8 = 1 << 0; // i
+pub static FLAG_MULTI: u8 = 1 << 1; // m
+pub static FLAG_DOTNL: u8 = 1 << 2; // s
+pub static FLAG_SWAP_GREED: u8 = 1 << 3; // U
+pub static FLAG_NEGATED: u8 = 1 << 4; // char class or not word boundary
+
+struct Parser<'a> {
+ // The input, parsed only as a sequence of UTF8 code points.
+ chars: Vec<char>,
+ // The index of the current character in the input.
+ chari: uint,
+ // The intermediate state representing the AST.
+ stack: Vec<BuildAst>,
+ // The current set of flags.
+ flags: Flags,
+ // The total number of capture groups.
+ // Incremented each time an opening left paren is seen (assuming it is
+ // opening a capture group).
+ caps: uint,
+ // A set of all capture group names used only to detect duplicates.
+ names: Vec<String>,
+}
+
+pub fn parse(s: &str) -> Result<Ast, Error> {
+ Parser {
+ chars: s.chars().collect(),
+ chari: 0,
+ stack: vec!(),
+ flags: FLAG_EMPTY,
+ caps: 0,
+ names: vec!(),
+ }.parse()
+}
+
+impl<'a> Parser<'a> {
+ fn parse(&mut self) -> Result<Ast, Error> {
+ if self.chars.len() == 0 {
+ return Ok(Nothing);
+ }
+ loop {
+ let c = self.cur();
+ match c {
+ '?' | '*' | '+' => try!(self.push_repeater(c)),
+ '\\' => {
+ let ast = try!(self.parse_escape());
+ self.push(ast)
+ }
+ '{' => try!(self.parse_counted()),
+ '[' => match self.try_parse_ascii() {
+ None => try!(self.parse_class()),
+ Some(class) => self.push(class),
+ },
+ '(' => {
+ if self.peek_is(1, '?') {
+ try!(self.expect('?'))
+ try!(self.parse_group_opts())
+ } else {
+ self.caps += 1;
+ self.stack.push(Paren(self.flags,
+ self.caps,
+ "".to_string()))
+ }
+ }
+ ')' => {
+ let catfrom = try!(
+ self.pos_last(false, |x| x.paren() || x.bar()));
+ try!(self.concat(catfrom));
+
+ let altfrom = try!(self.pos_last(false, |x| x.paren()));
+ // Before we smush the alternates together and pop off the
+ // left paren, let's grab the old flags and see if we
+ // need a capture.
+ let (cap, cap_name, oldflags) = {
+ let paren = self.stack.get(altfrom-1);
+ (paren.capture(), paren.capture_name(), paren.flags())
+ };
+ try!(self.alternate(altfrom));
+ self.flags = oldflags;
+
+ // If this was a capture, pop what we just pushed in
+ // alternate and make it a capture.
+ if cap.is_some() {
+ let ast = try!(self.pop_ast());
+ self.push(Capture(cap.unwrap(), cap_name, box ast));
+ }
+ }
+ '|' => {
+ let catfrom = try!(
+ self.pos_last(true, |x| x.paren() || x.bar()));
+ try!(self.concat(catfrom));
+
+ self.stack.push(Bar);
+ }
+ _ => try!(self.push_literal(c)),
+ }
+ if !self.next_char() {
+ break
+ }
+ }
+
+ // Try to improve error handling. At this point, there should be
+ // no remaining open parens.
+ if self.stack.iter().any(|x| x.paren()) {
+ return self.err("Unclosed parenthesis.")
+ }
+ let catfrom = try!(self.pos_last(true, |x| x.bar()));
+ try!(self.concat(catfrom));
+ try!(self.alternate(0));
+
+ assert!(self.stack.len() == 1);
+ self.pop_ast()
+ }
+
+ fn noteof(&mut self, expected: &str) -> Result<(), Error> {
+ match self.next_char() {
+ true => Ok(()),
+ false => {
+ self.err(format!("Expected {} but got EOF.",
+ expected).as_slice())
+ }
+ }
+ }
+
+ fn expect(&mut self, expected: char) -> Result<(), Error> {
+ match self.next_char() {
+ true if self.cur() == expected => Ok(()),
+ true => self.err(format!("Expected '{}' but got '{}'.",
+ expected, self.cur()).as_slice()),
+ false => {
+ self.err(format!("Expected '{}' but got EOF.",
+ expected).as_slice())
+ }
+ }
+ }
+
+ fn next_char(&mut self) -> bool {
+ self.chari += 1;
+ self.chari < self.chars.len()
+ }
+
+ fn pop_ast(&mut self) -> Result<Ast, Error> {
+ match self.stack.pop().unwrap().unwrap() {
+ Err(e) => Err(e),
+ Ok(ast) => Ok(ast),
+ }
+ }
+
+ fn push(&mut self, ast: Ast) {
+ self.stack.push(Ast(ast))
+ }
+
+ fn push_repeater(&mut self, c: char) -> Result<(), Error> {
+ if self.stack.len() == 0 {
+ return self.err(
+ "A repeat operator must be preceded by a valid expression.")
+ }
+ let rep: Repeater = match c {
+ '?' => ZeroOne, '*' => ZeroMore, '+' => OneMore,
+ _ => fail!("Not a valid repeater operator."),
+ };
+
+ match self.peek(1) {
+ Some('*') | Some('+') =>
+ return self.err(
+ "Double repeat operators are not supported."),
+ _ => {},
+ }
+ let ast = try!(self.pop_ast());
+ match ast {
+ Begin(_) | End(_) | WordBoundary(_) =>
+ return self.err(
+ "Repeat arguments cannot be empty width assertions."),
+ _ => {}
+ }
+ let greed = try!(self.get_next_greedy());
+ self.push(Rep(box ast, rep, greed));
+ Ok(())
+ }
+
+ fn push_literal(&mut self, c: char) -> Result<(), Error> {
+ let flags = self.flags;
+ match c {
+ '.' => {
+ self.push(Dot(flags))
+ }
+ '^' => {
+ self.push(Begin(flags))
+ }
+ '$' => {
+ self.push(End(flags))
+ }
+ _ => {
+ self.push(Literal(c, flags))
+ }
+ }
+ Ok(())
+ }
+
+ // Parses all forms of character classes.
+ // Assumes that '[' is the current character.
+ fn parse_class(&mut self) -> Result<(), Error> {
+ let negated =
+ if self.peek_is(1, '^') {
+ try!(self.expect('^'))
+ FLAG_NEGATED
+ } else {
+ FLAG_EMPTY
+ };
+ let mut ranges: Vec<(char, char)> = vec!();
+ let mut alts: Vec<Ast> = vec!();
+
+ if self.peek_is(1, ']') {
+ try!(self.expect(']'))
+ ranges.push((']', ']'))
+ }
+ while self.peek_is(1, '-') {
+ try!(self.expect('-'))
+ ranges.push(('-', '-'))
+ }
+ loop {
+ try!(self.noteof("a closing ']' or a non-empty character class)"))
+ let mut c = self.cur();
+ match c {
+ '[' =>
+ match self.try_parse_ascii() {
+ Some(Class(asciis, flags)) => {
+ alts.push(Class(asciis, flags ^ negated));
+ continue
+ }
+ Some(ast) =>
+ fail!("Expected Class AST but got '{}'", ast),
+ // Just drop down and try to add as a regular character.
+ None => {},
+ },
+ '\\' => {
+ match try!(self.parse_escape()) {
+ Class(asciis, flags) => {
+ alts.push(Class(asciis, flags ^ negated));
+ continue
+ }
+ Literal(c2, _) => c = c2, // process below
+ Begin(_) | End(_) | WordBoundary(_) =>
+ return self.err(
+ "\\A, \\z, \\b and \\B are not valid escape \
+ sequences inside a character class."),
+ ast => fail!("Unexpected AST item '{}'", ast),
+ }
+ }
+ _ => {},
+ }
+ match c {
+ ']' => {
+ if ranges.len() > 0 {
+ let flags = negated | (self.flags & FLAG_NOCASE);
+ let mut ast = Class(combine_ranges(ranges), flags);
+ for alt in alts.move_iter() {
+ ast = Alt(box alt, box ast)
+ }
+ self.push(ast);
+ } else if alts.len() > 0 {
+ let mut ast = alts.pop().unwrap();
+ for alt in alts.move_iter() {
+ ast = Alt(box alt, box ast)
+ }
+ self.push(ast);
+ }
+ return Ok(())
+ }
+ c => {
+ if self.peek_is(1, '-') && !self.peek_is(2, ']') {
+ try!(self.expect('-'))
+ try!(self.noteof("not a ']'"))
+ let c2 = self.cur();
+ if c2 < c {
+ return self.err(format!("Invalid character class \
+ range '{}-{}'",
+ c,
+ c2).as_slice())
+ }
+ ranges.push((c, self.cur()))
+ } else {
+ ranges.push((c, c))
+ }
+ }
+ }
+ }
+ }
+
+ // Tries to parse an ASCII character class of the form [:name:].
+ // If successful, returns an AST character class corresponding to name
+ // and moves the parser to the final ']' character.
+ // If unsuccessful, no state is changed and None is returned.
+ // Assumes that '[' is the current character.
+ fn try_parse_ascii(&mut self) -> Option<Ast> {
+ if !self.peek_is(1, ':') {
+ return None
+ }
+ let closer =
+ match self.pos(']') {
+ Some(i) => i,
+ None => return None,
+ };
+ if *self.chars.get(closer-1) != ':' {
+ return None
+ }
+ if closer - self.chari <= 3 {
+ return None
+ }
+ let mut name_start = self.chari + 2;
+ let negated =
+ if self.peek_is(2, '^') {
+ name_start += 1;
+ FLAG_NEGATED
+ } else {
+ FLAG_EMPTY
+ };
+ let name = self.slice(name_start, closer - 1);
+ match find_class(ASCII_CLASSES, name.as_slice()) {
+ None => None,
+ Some(ranges) => {
+ self.chari = closer;
+ let flags = negated | (self.flags & FLAG_NOCASE);
+ Some(Class(combine_ranges(ranges), flags))
+ }
+ }
+ }
+
+ // Parses counted repetition. Supports:
+ // {n}, {n,}, {n,m}, {n}?, {n,}? and {n,m}?
+ // Assumes that '{' is the current character.
+ // Returns either an error or moves the parser to the final '}' character.
+ // (Or the '?' character if not greedy.)
+ fn parse_counted(&mut self) -> Result<(), Error> {
+ // Scan until the closing '}' and grab the stuff in {}.
+ let start = self.chari;
+ let closer =
+ match self.pos('}') {
+ Some(i) => i,
+ None => {
+ return self.err(format!("No closing brace for counted \
+ repetition starting at position \
+ {}.",
+ start).as_slice())
+ }
+ };
+ self.chari = closer;
+ let greed = try!(self.get_next_greedy());
+ let inner = str::from_chars(
+ self.chars.as_slice().slice(start + 1, closer));
+
+ // Parse the min and max values from the regex.
+ let (mut min, mut max): (uint, Option<uint>);
+ if !inner.as_slice().contains(",") {
+ min = try!(self.parse_uint(inner.as_slice()));
+ max = Some(min);
+ } else {
+ let pieces: Vec<&str> = inner.as_slice().splitn(',', 1).collect();
+ let (smin, smax) = (*pieces.get(0), *pieces.get(1));
+ if smin.len() == 0 {
+ return self.err("Max repetitions cannot be specified \
+ without min repetitions.")
+ }
+ min = try!(self.parse_uint(smin));
+ max =
+ if smax.len() == 0 {
+ None
+ } else {
+ Some(try!(self.parse_uint(smax)))
+ };
+ }
+
+ // Do some bounds checking and make sure max >= min.
+ if min > MAX_REPEAT {
+ return self.err(format!(
+ "{} exceeds maximum allowed repetitions ({})",
+ min, MAX_REPEAT).as_slice());
+ }
+ if max.is_some() {
+ let m = max.unwrap();
+ if m > MAX_REPEAT {
+ return self.err(format!(
+ "{} exceeds maximum allowed repetitions ({})",
+ m, MAX_REPEAT).as_slice());
+ }
+ if m < min {
+ return self.err(format!(
+ "Max repetitions ({}) cannot be smaller than min \
+ repetitions ({}).", m, min).as_slice());
+ }
+ }
+
+ // Now manipulate the AST be repeating elements.
+ if max.is_none() {
+ // Require N copies of what's on the stack and then repeat it.
+ let ast = try!(self.pop_ast());
+ for _ in iter::range(0, min) {
+ self.push(ast.clone())
+ }
+ self.push(Rep(box ast, ZeroMore, greed));
+ } else {
+ // Require N copies of what's on the stack and then repeat it
+ // up to M times optionally.
+ let ast = try!(self.pop_ast());
+ for _ in iter::range(0, min) {
+ self.push(ast.clone())
+ }
+ if max.is_some() {
+ for _ in iter::range(min, max.unwrap()) {
+ self.push(Rep(box ast.clone(), ZeroOne, greed))
+ }
+ }
+ // It's possible that we popped something off the stack but
+ // never put anything back on it. To keep things simple, add
+ // a no-op expression.
+ if min == 0 && (max.is_none() || max == Some(0)) {
+ self.push(Nothing)
+ }
+ }
+ Ok(())
+ }
+
+ // Parses all escape sequences.
+ // Assumes that '\' is the current character.
+ fn parse_escape(&mut self) -> Result<Ast, Error> {
+ try!(self.noteof("an escape sequence following a '\\'"))
+
+ let c = self.cur();
+ if is_punct(c) {
+ return Ok(Literal(c, FLAG_EMPTY))
+ }
+ match c {
+ 'a' => Ok(Literal('\x07', FLAG_EMPTY)),
+ 'f' => Ok(Literal('\x0C', FLAG_EMPTY)),
+ 't' => Ok(Literal('\t', FLAG_EMPTY)),
+ 'n' => Ok(Literal('\n', FLAG_EMPTY)),
+ 'r' => Ok(Literal('\r', FLAG_EMPTY)),
+ 'v' => Ok(Literal('\x0B', FLAG_EMPTY)),
+ 'A' => Ok(Begin(FLAG_EMPTY)),
+ 'z' => Ok(End(FLAG_EMPTY)),
+ 'b' => Ok(WordBoundary(FLAG_EMPTY)),
+ 'B' => Ok(WordBoundary(FLAG_NEGATED)),
+ '0'|'1'|'2'|'3'|'4'|'5'|'6'|'7' => Ok(try!(self.parse_octal())),
+ 'x' => Ok(try!(self.parse_hex())),
+ 'p' | 'P' => Ok(try!(self.parse_unicode_name())),
+ 'd' | 'D' | 's' | 'S' | 'w' | 'W' => {
+ let ranges = perl_unicode_class(c);
+ let mut flags = self.flags & FLAG_NOCASE;
+ if c.is_uppercase() { flags |= FLAG_NEGATED }
+ Ok(Class(ranges, flags))
+ }
+ _ => {
+ self.err(format!("Invalid escape sequence '\\\\{}'",
+ c).as_slice())
+ }
+ }
+ }
+
+ // Parses a unicode character class name, either of the form \pF where
+ // F is a one letter unicode class name or of the form \p{name} where
+ // name is the unicode class name.
+ // Assumes that \p or \P has been read (and 'p' or 'P' is the current
+ // character).
+ fn parse_unicode_name(&mut self) -> Result<Ast, Error> {
+ let negated = if self.cur() == 'P' { FLAG_NEGATED } else { FLAG_EMPTY };
+ let mut name: String;
+ if self.peek_is(1, '{') {
+ try!(self.expect('{'))
+ let closer =
+ match self.pos('}') {
+ Some(i) => i,
+ None => return self.err(format!(
+ "Missing '}}' for unclosed '{{' at position {}",
+ self.chari).as_slice()),
+ };
+ if closer - self.chari + 1 == 0 {
+ return self.err("No Unicode class name found.")
+ }
+ name = self.slice(self.chari + 1, closer);
+ self.chari = closer;
+ } else {
+ if self.chari + 1 >= self.chars.len() {
+ return self.err("No single letter Unicode class name found.")
+ }
+ name = self.slice(self.chari + 1, self.chari + 2);
+ self.chari += 1;
+ }
+ match find_class(UNICODE_CLASSES, name.as_slice()) {
+ None => {
+ return self.err(format!("Could not find Unicode class '{}'",
+ name).as_slice())
+ }
+ Some(ranges) => {
+ Ok(Class(ranges, negated | (self.flags & FLAG_NOCASE)))
+ }
+ }
+ }
+
+ // Parses an octal number, up to 3 digits.
+ // Assumes that \n has been read, where n is the first digit.
+ fn parse_octal(&mut self) -> Result<Ast, Error> {
+ let start = self.chari;
+ let mut end = start + 1;
+ let (d2, d3) = (self.peek(1), self.peek(2));
+ if d2 >= Some('0') && d2 <= Some('7') {
+ try!(self.noteof("expected octal character in [0-7]"))
+ end += 1;
+ if d3 >= Some('0') && d3 <= Some('7') {
+ try!(self.noteof("expected octal character in [0-7]"))
+ end += 1;
+ }
+ }
+ let s = self.slice(start, end);
+ match num::from_str_radix::<u32>(s.as_slice(), 8) {
+ Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
+ None => {
+ self.err(format!("Could not parse '{}' as octal number.",
+ s).as_slice())
+ }
+ }
+ }
+
+ // Parse a hex number. Either exactly two digits or anything in {}.
+ // Assumes that \x has been read.
+ fn parse_hex(&mut self) -> Result<Ast, Error> {
+ if !self.peek_is(1, '{') {
+ try!(self.expect('{'))
+ return self.parse_hex_two()
+ }
+ let start = self.chari + 2;
+ let closer =
+ match self.pos('}') {
+ None => {
+ return self.err(format!("Missing '}}' for unclosed \
+ '{{' at position {}",
+ start).as_slice())
+ }
+ Some(i) => i,
+ };
+ self.chari = closer;
+ self.parse_hex_digits(self.slice(start, closer).as_slice())
+ }
+
+ // Parses a two-digit hex number.
+ // Assumes that \xn has been read, where n is the first digit and is the
+ // current character.
+ // After return, parser will point at the second digit.
+ fn parse_hex_two(&mut self) -> Result<Ast, Error> {
+ let (start, end) = (self.chari, self.chari + 2);
+ let bad = self.slice(start - 2, self.chars.len());
+ try!(self.noteof(format!("Invalid hex escape sequence '{}'",
+ bad).as_slice()))
+ self.parse_hex_digits(self.slice(start, end).as_slice())
+ }
+
+ // Parses `s` as a hexadecimal number.
+ fn parse_hex_digits(&self, s: &str) -> Result<Ast, Error> {
+ match num::from_str_radix::<u32>(s, 16) {
+ Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
+ None => {
+ self.err(format!("Could not parse '{}' as hex number.",
+ s).as_slice())
+ }
+ }
+ }
+
+ // Parses a named capture.
+ // Assumes that '(?P<' has been consumed and that the current character
+ // is '<'.
+ // When done, parser will be at the closing '>' character.
+ fn parse_named_capture(&mut self) -> Result<(), Error> {
+ try!(self.noteof("a capture name"))
+ let closer =
+ match self.pos('>') {
+ Some(i) => i,
+ None => return self.err("Capture name must end with '>'."),
+ };
+ if closer - self.chari == 0 {
+ return self.err("Capture names must have at least 1 character.")
+ }
+ let name = self.slice(self.chari, closer);
+ if !name.as_slice().chars().all(is_valid_cap) {
+ return self.err(
+ "Capture names can only have underscores, letters and digits.")
+ }
+ if self.names.contains(&name) {
+ return self.err(format!("Duplicate capture group name '{}'.",
+ name).as_slice())
+ }
+ self.names.push(name.clone());
+ self.chari = closer;
+ self.caps += 1;
+ self.stack.push(Paren(self.flags, self.caps, name));
+ Ok(())
+ }
+
+ // Parses non-capture groups and options.
+ // Assumes that '(?' has already been consumed and '?' is the current
+ // character.
+ fn parse_group_opts(&mut self) -> Result<(), Error> {
+ if self.peek_is(1, 'P') && self.peek_is(2, '<') {
+ try!(self.expect('P')) try!(self.expect('<'))
+ return self.parse_named_capture()
+ }
+ let start = self.chari;
+ let mut flags = self.flags;
+ let mut sign = 1i;
+ let mut saw_flag = false;
+ loop {
+ try!(self.noteof("expected non-empty set of flags or closing ')'"))
+ match self.cur() {
+ 'i' => { flags = flags | FLAG_NOCASE; saw_flag = true},
+ 'm' => { flags = flags | FLAG_MULTI; saw_flag = true},
+ 's' => { flags = flags | FLAG_DOTNL; saw_flag = true},
+ 'U' => { flags = flags | FLAG_SWAP_GREED; saw_flag = true},
+ '-' => {
+ if sign < 0 {
+ return self.err(format!(
+ "Cannot negate flags twice in '{}'.",
+ self.slice(start, self.chari + 1)).as_slice())
+ }
+ sign = -1;
+ saw_flag = false;
+ flags = flags ^ flags;
+ }
+ ':' | ')' => {
+ if sign < 0 {
+ if !saw_flag {
+ return self.err(format!(
+ "A valid flag does not follow negation in '{}'",
+ self.slice(start, self.chari + 1)).as_slice())
+ }
+ flags = flags ^ flags;
+ }
+ if self.cur() == ':' {
+ // Save the old flags with the opening paren.
+ self.stack.push(Paren(self.flags, 0, "".to_string()));
+ }
+ self.flags = flags;
+ return Ok(())
+ }
+ _ => return self.err(format!(
+ "Unrecognized flag '{}'.", self.cur()).as_slice()),
+ }
+ }
+ }
+
+ // Peeks at the next character and returns whether it's ungreedy or not.
+ // If it is, then the next character is consumed.
+ fn get_next_greedy(&mut self) -> Result<Greed, Error> {
+ Ok(if self.peek_is(1, '?') {
+ try!(self.expect('?'))
+ Ungreedy
+ } else {
+ Greedy
+ }.swap(self.flags & FLAG_SWAP_GREED > 0))
+ }
+
+ // Searches the stack (starting at the top) until it finds an expression
+ // for which `pred` returns true. The index of that expression in the
+ // stack is returned.
+ // If there's no match, then one of two things happens depending on the
+ // values of `allow_start`. When it's true, then `0` will be returned.
+ // Otherwise, an error will be returned.
+ // Generally, `allow_start` is only true when you're *not* expecting an
+ // opening parenthesis.
+ fn pos_last(&self, allow_start: bool, pred: |&BuildAst| -> bool)
+ -> Result<uint, Error> {
+ let from = match self.stack.iter().rev().position(pred) {
+ Some(i) => i,
+ None => {
+ if allow_start {
+ self.stack.len()
+ } else {
+ return self.err("No matching opening parenthesis.")
+ }
+ }
+ };
+ // Adjust index since 'from' is for the reversed stack.
+ // Also, don't include the '(' or '|'.
+ Ok(self.stack.len() - from)
+ }
+
+ // concat starts at `from` in the parser's stack and concatenates all
+ // expressions up to the top of the stack. The resulting concatenation is
+ // then pushed on to the stack.
+ // Usually `from` corresponds to the position of an opening parenthesis,
+ // a '|' (alternation) or the start of the entire expression.
+ fn concat(&mut self, from: uint) -> Result<(), Error> {
+ let ast = try!(self.build_from(from, concat_flatten));
+ self.push(ast);
+ Ok(())
+ }
+
+ // concat starts at `from` in the parser's stack and alternates all
+ // expressions up to the top of the stack. The resulting alternation is
+ // then pushed on to the stack.
+ // Usually `from` corresponds to the position of an opening parenthesis
+ // or the start of the entire expression.
+ // This will also drop any opening parens or alternation bars found in
+ // the intermediate AST.
+ fn alternate(&mut self, mut from: uint) -> Result<(), Error> {
+ // Unlike in the concatenation case, we want 'build_from' to continue
+ // all the way to the opening left paren (so it will be popped off and
+ // thrown away). But be careful with overflow---we can't count on the
+ // open paren to be there.
+ if from > 0 { from = from - 1}
+ let ast = try!(self.build_from(from, |l,r| Alt(box l, box r)));
+ self.push(ast);
+ Ok(())
+ }
+
+ // build_from combines all AST elements starting at 'from' in the
+ // parser's stack using 'mk' to combine them. If any such element is not an
+ // AST then it is popped off the stack and ignored.
+ fn build_from(&mut self, from: uint, mk: |Ast, Ast| -> Ast)
+ -> Result<Ast, Error> {
+ if from >= self.stack.len() {
+ return self.err("Empty group or alternate not allowed.")
+ }
+
+ let mut combined = try!(self.pop_ast());
+ let mut i = self.stack.len();
+ while i > from {
+ i = i - 1;
+ match self.stack.pop().unwrap() {
+ Ast(x) => combined = mk(x, combined),
+ _ => {},
+ }
+ }
+ Ok(combined)
+ }
+
+ fn parse_uint(&self, s: &str) -> Result<uint, Error> {
+ match from_str::<uint>(s) {
+ Some(i) => Ok(i),
+ None => {
+ self.err(format!("Expected an unsigned integer but got '{}'.",
+ s).as_slice())
+ }
+ }
+ }
+
+ fn char_from_u32(&self, n: u32) -> Result<char, Error> {
+ match char::from_u32(n) {
+ Some(c) => Ok(c),
+ None => {
+ self.err(format!("Could not decode '{}' to unicode \
+ character.",
+ n).as_slice())
+ }
+ }
+ }
+
+ fn pos(&self, c: char) -> Option<uint> {
+ self.chars.iter()
+ .skip(self.chari).position(|&c2| c2 == c).map(|i| self.chari + i)
+ }
+
+ fn err<T>(&self, msg: &str) -> Result<T, Error> {
+ Err(Error {
+ pos: self.chari,
+ msg: msg.to_string(),
+ })
+ }
+
+ fn peek(&self, offset: uint) -> Option<char> {
+ if self.chari + offset >= self.chars.len() {
+ return None
+ }
+ Some(*self.chars.get(self.chari + offset))
+ }
+
+ fn peek_is(&self, offset: uint, is: char) -> bool {
+ self.peek(offset) == Some(is)
+ }
+
+ fn cur(&self) -> char {
+ *self.chars.get(self.chari)
+ }
+
+ fn slice(&self, start: uint, end: uint) -> String {
+ str::from_chars(self.chars.as_slice().slice(start, end)).to_string()
+ }
+}
+
+// Given an unordered collection of character ranges, combine_ranges returns
+// an ordered sequence of character ranges where no two ranges overlap. They
+// are ordered from least to greatest (using start position).
+fn combine_ranges(unordered: Vec<(char, char)>) -> Vec<(char, char)> {
+ // Returns true iff the two character classes overlap or share a boundary.
+ // e.g., ('a', 'g') and ('h', 'm') would return true.
+ fn should_merge((a, b): (char, char), (x, y): (char, char)) -> bool {
+ cmp::max(a, x) as u32 <= cmp::min(b, y) as u32 + 1
+ }
+
+ // This is currently O(n^2), but I think with sufficient cleverness,
+ // it can be reduced to O(n) **if necessary**.
+ let mut ordered: Vec<(char, char)> = Vec::with_capacity(unordered.len());
+ for (us, ue) in unordered.move_iter() {
+ let (mut us, mut ue) = (us, ue);
+ assert!(us <= ue);
+ let mut which: Option<uint> = None;
+ for (i, &(os, oe)) in ordered.iter().enumerate() {
+ if should_merge((us, ue), (os, oe)) {
+ us = cmp::min(us, os);
+ ue = cmp::max(ue, oe);
+ which = Some(i);
+ break
+ }
+ }
+ match which {
+ None => ordered.push((us, ue)),
+ Some(i) => *ordered.get_mut(i) = (us, ue),
+ }
+ }
+ ordered.sort();
+ ordered
+}
+
+// Constructs a Unicode friendly Perl character class from \d, \s or \w
+// (or any of their negated forms). Note that this does not handle negation.
+fn perl_unicode_class(which: char) -> Vec<(char, char)> {
+ match which.to_lowercase() {
+ 'd' => Vec::from_slice(PERLD),
+ 's' => Vec::from_slice(PERLS),
+ 'w' => Vec::from_slice(PERLW),
+ _ => unreachable!(),
+ }
+}
+
+// Returns a concatenation of two expressions. This also guarantees that a
+// `Cat` expression will never be a direct child of another `Cat` expression.
+fn concat_flatten(x: Ast, y: Ast) -> Ast {
+ match (x, y) {
+ (Cat(mut xs), Cat(ys)) => { xs.push_all_move(ys); Cat(xs) }
+ (Cat(mut xs), ast) => { xs.push(ast); Cat(xs) }
+ (ast, Cat(mut xs)) => { xs.unshift(ast); Cat(xs) }
+ (ast1, ast2) => Cat(vec!(ast1, ast2)),
+ }
+}
+
+pub fn is_punct(c: char) -> bool {
+ match c {
+ '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' |
+ '[' | ']' | '{' | '}' | '^' | '$' => true,
+ _ => false,
+ }
+}
+
+fn is_valid_cap(c: char) -> bool {
+ c == '_' || (c >= '0' && c <= '9')
+ || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+}
+
+fn find_class(classes: NamedClasses, name: &str) -> Option<Vec<(char, char)>> {
+ match classes.bsearch(|&(s, _)| s.cmp(&name)) {
+ Some(i) => Some(Vec::from_slice(classes[i].val1())),
+ None => None,
+ }
+}
+
+type Class = &'static [(char, char)];
+type NamedClasses = &'static [(&'static str, Class)];
+
+static ASCII_CLASSES: NamedClasses = &[
+ // Classes must be in alphabetical order so that bsearch works.
+ // [:alnum:] alphanumeric (== [0-9A-Za-z])
+ // [:alpha:] alphabetic (== [A-Za-z])
+ // [:ascii:] ASCII (== [\x00-\x7F])
+ // [:blank:] blank (== [\t ])
+ // [:cntrl:] control (== [\x00-\x1F\x7F])
+ // [:digit:] digits (== [0-9])
+ // [:graph:] graphical (== [!-~])
+ // [:lower:] lower case (== [a-z])
+ // [:print:] printable (== [ -~] == [ [:graph:]])
+ // [:punct:] punctuation (== [!-/:-@[-`{-~])
+ // [:space:] whitespace (== [\t\n\v\f\r ])
+ // [:upper:] upper case (== [A-Z])
+ // [:word:] word characters (== [0-9A-Za-z_])
+ // [:xdigit:] hex digit (== [0-9A-Fa-f])
+ // Taken from: http://golang.org/pkg/regex/syntax/
+ ("alnum", &[('0', '9'), ('A', 'Z'), ('a', 'z')]),
+ ("alpha", &[('A', 'Z'), ('a', 'z')]),
+ ("ascii", &[('\x00', '\x7F')]),
+ ("blank", &[(' ', ' '), ('\t', '\t')]),
+ ("cntrl", &[('\x00', '\x1F'), ('\x7F', '\x7F')]),
+ ("digit", &[('0', '9')]),
+ ("graph", &[('!', '~')]),
+ ("lower", &[('a', 'z')]),
+ ("print", &[(' ', '~')]),
+ ("punct", &[('!', '/'), (':', '@'), ('[', '`'), ('{', '~')]),
+ ("space", &[('\t', '\t'), ('\n', '\n'), ('\x0B', '\x0B'), ('\x0C', '\x0C'),
+ ('\r', '\r'), (' ', ' ')]),
+ ("upper", &[('A', 'Z')]),
+ ("word", &[('0', '9'), ('A', 'Z'), ('a', 'z'), ('_', '_')]),
+ ("xdigit", &[('0', '9'), ('A', 'F'), ('a', 'f')]),
+];
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::char;
-use std::cmp;
-use std::fmt;
-use std::iter;
-use std::num;
-use std::str;
-
-/// Static data containing Unicode ranges for general categories and scripts.
-use self::unicode::{UNICODE_CLASSES, PERLD, PERLS, PERLW};
-#[allow(visible_private_types)]
-pub mod unicode;
-
-/// The maximum number of repetitions allowed with the `{n,m}` syntax.
-static MAX_REPEAT: uint = 1000;
-
-/// Error corresponds to something that can go wrong while parsing
-/// a regular expression.
-///
-/// (Once an expression is compiled, it is not possible to produce an error
-/// via searching, splitting or replacing.)
-pub struct Error {
- /// The *approximate* character index of where the error occurred.
- pub pos: uint,
- /// A message describing the error.
- pub msg: String,
-}
-
-impl fmt::Show for Error {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "Regex syntax error near position {}: {}",
- self.pos, self.msg)
- }
-}
-
-/// Represents the abstract syntax of a regular expression.
-/// It is showable so that error messages resulting from a bug can provide
-/// useful information.
-/// It is cloneable so that expressions can be repeated for the counted
-/// repetition feature. (No other copying is done.)
-///
-/// Note that this representation prevents one from reproducing the regex as
-/// it was typed. (But it could be used to reproduce an equivalent regex.)
-#[deriving(Show, Clone)]
-pub enum Ast {
- Nothing,
- Literal(char, Flags),
- Dot(Flags),
- Class(Vec<(char, char)>, Flags),
- Begin(Flags),
- End(Flags),
- WordBoundary(Flags),
- Capture(uint, Option<String>, Box<Ast>),
- // Represent concatenation as a flat vector to avoid blowing the
- // stack in the compiler.
- Cat(Vec<Ast>),
- Alt(Box<Ast>, Box<Ast>),
- Rep(Box<Ast>, Repeater, Greed),
-}
-
-#[deriving(Show, PartialEq, Clone)]
-pub enum Repeater {
- ZeroOne,
- ZeroMore,
- OneMore,
-}
-
-#[deriving(Show, Clone)]
-pub enum Greed {
- Greedy,
- Ungreedy,
-}
-
-impl Greed {
- pub fn is_greedy(&self) -> bool {
- match *self {
- Greedy => true,
- _ => false,
- }
- }
-
- fn swap(self, swapped: bool) -> Greed {
- if !swapped { return self }
- match self {
- Greedy => Ungreedy,
- Ungreedy => Greedy,
- }
- }
-}
-
-/// BuildAst is a regrettable type that represents intermediate state for
-/// constructing an abstract syntax tree. Its central purpose is to facilitate
-/// parsing groups and alternations while also maintaining a stack of flag
-/// state.
-#[deriving(Show)]
-enum BuildAst {
- Ast(Ast),
- Paren(Flags, uint, String), // '('
- Bar, // '|'
-}
-
-impl BuildAst {
- fn paren(&self) -> bool {
- match *self {
- Paren(_, _, _) => true,
- _ => false,
- }
- }
-
- fn flags(&self) -> Flags {
- match *self {
- Paren(flags, _, _) => flags,
- _ => fail!("Cannot get flags from {}", self),
- }
- }
-
- fn capture(&self) -> Option<uint> {
- match *self {
- Paren(_, 0, _) => None,
- Paren(_, c, _) => Some(c),
- _ => fail!("Cannot get capture group from {}", self),
- }
- }
-
- fn capture_name(&self) -> Option<String> {
- match *self {
- Paren(_, 0, _) => None,
- Paren(_, _, ref name) => {
- if name.len() == 0 {
- None
- } else {
- Some(name.clone())
- }
- }
- _ => fail!("Cannot get capture name from {}", self),
- }
- }
-
- fn bar(&self) -> bool {
- match *self {
- Bar => true,
- _ => false,
- }
- }
-
- fn unwrap(self) -> Result<Ast, Error> {
- match self {
- Ast(x) => Ok(x),
- _ => fail!("Tried to unwrap non-AST item: {}", self),
- }
- }
-}
-
-/// Flags represents all options that can be twiddled by a user in an
-/// expression.
-pub type Flags = u8;
-
-pub static FLAG_EMPTY: u8 = 0;
-pub static FLAG_NOCASE: u8 = 1 << 0; // i
-pub static FLAG_MULTI: u8 = 1 << 1; // m
-pub static FLAG_DOTNL: u8 = 1 << 2; // s
-pub static FLAG_SWAP_GREED: u8 = 1 << 3; // U
-pub static FLAG_NEGATED: u8 = 1 << 4; // char class or not word boundary
-
-struct Parser<'a> {
- // The input, parsed only as a sequence of UTF8 code points.
- chars: Vec<char>,
- // The index of the current character in the input.
- chari: uint,
- // The intermediate state representing the AST.
- stack: Vec<BuildAst>,
- // The current set of flags.
- flags: Flags,
- // The total number of capture groups.
- // Incremented each time an opening left paren is seen (assuming it is
- // opening a capture group).
- caps: uint,
- // A set of all capture group names used only to detect duplicates.
- names: Vec<String>,
-}
-
-pub fn parse(s: &str) -> Result<Ast, Error> {
- Parser {
- chars: s.chars().collect(),
- chari: 0,
- stack: vec!(),
- flags: FLAG_EMPTY,
- caps: 0,
- names: vec!(),
- }.parse()
-}
-
-impl<'a> Parser<'a> {
- fn parse(&mut self) -> Result<Ast, Error> {
- if self.chars.len() == 0 {
- return Ok(Nothing);
- }
- loop {
- let c = self.cur();
- match c {
- '?' | '*' | '+' => try!(self.push_repeater(c)),
- '\\' => {
- let ast = try!(self.parse_escape());
- self.push(ast)
- }
- '{' => try!(self.parse_counted()),
- '[' => match self.try_parse_ascii() {
- None => try!(self.parse_class()),
- Some(class) => self.push(class),
- },
- '(' => {
- if self.peek_is(1, '?') {
- try!(self.expect('?'))
- try!(self.parse_group_opts())
- } else {
- self.caps += 1;
- self.stack.push(Paren(self.flags,
- self.caps,
- "".to_string()))
- }
- }
- ')' => {
- let catfrom = try!(
- self.pos_last(false, |x| x.paren() || x.bar()));
- try!(self.concat(catfrom));
-
- let altfrom = try!(self.pos_last(false, |x| x.paren()));
- // Before we smush the alternates together and pop off the
- // left paren, let's grab the old flags and see if we
- // need a capture.
- let (cap, cap_name, oldflags) = {
- let paren = self.stack.get(altfrom-1);
- (paren.capture(), paren.capture_name(), paren.flags())
- };
- try!(self.alternate(altfrom));
- self.flags = oldflags;
-
- // If this was a capture, pop what we just pushed in
- // alternate and make it a capture.
- if cap.is_some() {
- let ast = try!(self.pop_ast());
- self.push(Capture(cap.unwrap(), cap_name, box ast));
- }
- }
- '|' => {
- let catfrom = try!(
- self.pos_last(true, |x| x.paren() || x.bar()));
- try!(self.concat(catfrom));
-
- self.stack.push(Bar);
- }
- _ => try!(self.push_literal(c)),
- }
- if !self.next_char() {
- break
- }
- }
-
- // Try to improve error handling. At this point, there should be
- // no remaining open parens.
- if self.stack.iter().any(|x| x.paren()) {
- return self.err("Unclosed parenthesis.")
- }
- let catfrom = try!(self.pos_last(true, |x| x.bar()));
- try!(self.concat(catfrom));
- try!(self.alternate(0));
-
- assert!(self.stack.len() == 1);
- self.pop_ast()
- }
-
- fn noteof(&mut self, expected: &str) -> Result<(), Error> {
- match self.next_char() {
- true => Ok(()),
- false => {
- self.err(format!("Expected {} but got EOF.",
- expected).as_slice())
- }
- }
- }
-
- fn expect(&mut self, expected: char) -> Result<(), Error> {
- match self.next_char() {
- true if self.cur() == expected => Ok(()),
- true => self.err(format!("Expected '{}' but got '{}'.",
- expected, self.cur()).as_slice()),
- false => {
- self.err(format!("Expected '{}' but got EOF.",
- expected).as_slice())
- }
- }
- }
-
- fn next_char(&mut self) -> bool {
- self.chari += 1;
- self.chari < self.chars.len()
- }
-
- fn pop_ast(&mut self) -> Result<Ast, Error> {
- match self.stack.pop().unwrap().unwrap() {
- Err(e) => Err(e),
- Ok(ast) => Ok(ast),
- }
- }
-
- fn push(&mut self, ast: Ast) {
- self.stack.push(Ast(ast))
- }
-
- fn push_repeater(&mut self, c: char) -> Result<(), Error> {
- if self.stack.len() == 0 {
- return self.err(
- "A repeat operator must be preceded by a valid expression.")
- }
- let rep: Repeater = match c {
- '?' => ZeroOne, '*' => ZeroMore, '+' => OneMore,
- _ => fail!("Not a valid repeater operator."),
- };
-
- match self.peek(1) {
- Some('*') | Some('+') =>
- return self.err(
- "Double repeat operators are not supported."),
- _ => {},
- }
- let ast = try!(self.pop_ast());
- match ast {
- Begin(_) | End(_) | WordBoundary(_) =>
- return self.err(
- "Repeat arguments cannot be empty width assertions."),
- _ => {}
- }
- let greed = try!(self.get_next_greedy());
- self.push(Rep(box ast, rep, greed));
- Ok(())
- }
-
- fn push_literal(&mut self, c: char) -> Result<(), Error> {
- let flags = self.flags;
- match c {
- '.' => {
- self.push(Dot(flags))
- }
- '^' => {
- self.push(Begin(flags))
- }
- '$' => {
- self.push(End(flags))
- }
- _ => {
- self.push(Literal(c, flags))
- }
- }
- Ok(())
- }
-
- // Parses all forms of character classes.
- // Assumes that '[' is the current character.
- fn parse_class(&mut self) -> Result<(), Error> {
- let negated =
- if self.peek_is(1, '^') {
- try!(self.expect('^'))
- FLAG_NEGATED
- } else {
- FLAG_EMPTY
- };
- let mut ranges: Vec<(char, char)> = vec!();
- let mut alts: Vec<Ast> = vec!();
-
- if self.peek_is(1, ']') {
- try!(self.expect(']'))
- ranges.push((']', ']'))
- }
- while self.peek_is(1, '-') {
- try!(self.expect('-'))
- ranges.push(('-', '-'))
- }
- loop {
- try!(self.noteof("a closing ']' or a non-empty character class)"))
- let mut c = self.cur();
- match c {
- '[' =>
- match self.try_parse_ascii() {
- Some(Class(asciis, flags)) => {
- alts.push(Class(asciis, flags ^ negated));
- continue
- }
- Some(ast) =>
- fail!("Expected Class AST but got '{}'", ast),
- // Just drop down and try to add as a regular character.
- None => {},
- },
- '\\' => {
- match try!(self.parse_escape()) {
- Class(asciis, flags) => {
- alts.push(Class(asciis, flags ^ negated));
- continue
- }
- Literal(c2, _) => c = c2, // process below
- Begin(_) | End(_) | WordBoundary(_) =>
- return self.err(
- "\\A, \\z, \\b and \\B are not valid escape \
- sequences inside a character class."),
- ast => fail!("Unexpected AST item '{}'", ast),
- }
- }
- _ => {},
- }
- match c {
- ']' => {
- if ranges.len() > 0 {
- let flags = negated | (self.flags & FLAG_NOCASE);
- let mut ast = Class(combine_ranges(ranges), flags);
- for alt in alts.move_iter() {
- ast = Alt(box alt, box ast)
- }
- self.push(ast);
- } else if alts.len() > 0 {
- let mut ast = alts.pop().unwrap();
- for alt in alts.move_iter() {
- ast = Alt(box alt, box ast)
- }
- self.push(ast);
- }
- return Ok(())
- }
- c => {
- if self.peek_is(1, '-') && !self.peek_is(2, ']') {
- try!(self.expect('-'))
- try!(self.noteof("not a ']'"))
- let c2 = self.cur();
- if c2 < c {
- return self.err(format!("Invalid character class \
- range '{}-{}'",
- c,
- c2).as_slice())
- }
- ranges.push((c, self.cur()))
- } else {
- ranges.push((c, c))
- }
- }
- }
- }
- }
-
- // Tries to parse an ASCII character class of the form [:name:].
- // If successful, returns an AST character class corresponding to name
- // and moves the parser to the final ']' character.
- // If unsuccessful, no state is changed and None is returned.
- // Assumes that '[' is the current character.
- fn try_parse_ascii(&mut self) -> Option<Ast> {
- if !self.peek_is(1, ':') {
- return None
- }
- let closer =
- match self.pos(']') {
- Some(i) => i,
- None => return None,
- };
- if *self.chars.get(closer-1) != ':' {
- return None
- }
- if closer - self.chari <= 3 {
- return None
- }
- let mut name_start = self.chari + 2;
- let negated =
- if self.peek_is(2, '^') {
- name_start += 1;
- FLAG_NEGATED
- } else {
- FLAG_EMPTY
- };
- let name = self.slice(name_start, closer - 1);
- match find_class(ASCII_CLASSES, name.as_slice()) {
- None => None,
- Some(ranges) => {
- self.chari = closer;
- let flags = negated | (self.flags & FLAG_NOCASE);
- Some(Class(combine_ranges(ranges), flags))
- }
- }
- }
-
- // Parses counted repetition. Supports:
- // {n}, {n,}, {n,m}, {n}?, {n,}? and {n,m}?
- // Assumes that '{' is the current character.
- // Returns either an error or moves the parser to the final '}' character.
- // (Or the '?' character if not greedy.)
- fn parse_counted(&mut self) -> Result<(), Error> {
- // Scan until the closing '}' and grab the stuff in {}.
- let start = self.chari;
- let closer =
- match self.pos('}') {
- Some(i) => i,
- None => {
- return self.err(format!("No closing brace for counted \
- repetition starting at position \
- {}.",
- start).as_slice())
- }
- };
- self.chari = closer;
- let greed = try!(self.get_next_greedy());
- let inner = str::from_chars(
- self.chars.as_slice().slice(start + 1, closer));
-
- // Parse the min and max values from the regex.
- let (mut min, mut max): (uint, Option<uint>);
- if !inner.as_slice().contains(",") {
- min = try!(self.parse_uint(inner.as_slice()));
- max = Some(min);
- } else {
- let pieces: Vec<&str> = inner.as_slice().splitn(',', 1).collect();
- let (smin, smax) = (*pieces.get(0), *pieces.get(1));
- if smin.len() == 0 {
- return self.err("Max repetitions cannot be specified \
- without min repetitions.")
- }
- min = try!(self.parse_uint(smin));
- max =
- if smax.len() == 0 {
- None
- } else {
- Some(try!(self.parse_uint(smax)))
- };
- }
-
- // Do some bounds checking and make sure max >= min.
- if min > MAX_REPEAT {
- return self.err(format!(
- "{} exceeds maximum allowed repetitions ({})",
- min, MAX_REPEAT).as_slice());
- }
- if max.is_some() {
- let m = max.unwrap();
- if m > MAX_REPEAT {
- return self.err(format!(
- "{} exceeds maximum allowed repetitions ({})",
- m, MAX_REPEAT).as_slice());
- }
- if m < min {
- return self.err(format!(
- "Max repetitions ({}) cannot be smaller than min \
- repetitions ({}).", m, min).as_slice());
- }
- }
-
- // Now manipulate the AST be repeating elements.
- if max.is_none() {
- // Require N copies of what's on the stack and then repeat it.
- let ast = try!(self.pop_ast());
- for _ in iter::range(0, min) {
- self.push(ast.clone())
- }
- self.push(Rep(box ast, ZeroMore, greed));
- } else {
- // Require N copies of what's on the stack and then repeat it
- // up to M times optionally.
- let ast = try!(self.pop_ast());
- for _ in iter::range(0, min) {
- self.push(ast.clone())
- }
- if max.is_some() {
- for _ in iter::range(min, max.unwrap()) {
- self.push(Rep(box ast.clone(), ZeroOne, greed))
- }
- }
- // It's possible that we popped something off the stack but
- // never put anything back on it. To keep things simple, add
- // a no-op expression.
- if min == 0 && (max.is_none() || max == Some(0)) {
- self.push(Nothing)
- }
- }
- Ok(())
- }
-
- // Parses all escape sequences.
- // Assumes that '\' is the current character.
- fn parse_escape(&mut self) -> Result<Ast, Error> {
- try!(self.noteof("an escape sequence following a '\\'"))
-
- let c = self.cur();
- if is_punct(c) {
- return Ok(Literal(c, FLAG_EMPTY))
- }
- match c {
- 'a' => Ok(Literal('\x07', FLAG_EMPTY)),
- 'f' => Ok(Literal('\x0C', FLAG_EMPTY)),
- 't' => Ok(Literal('\t', FLAG_EMPTY)),
- 'n' => Ok(Literal('\n', FLAG_EMPTY)),
- 'r' => Ok(Literal('\r', FLAG_EMPTY)),
- 'v' => Ok(Literal('\x0B', FLAG_EMPTY)),
- 'A' => Ok(Begin(FLAG_EMPTY)),
- 'z' => Ok(End(FLAG_EMPTY)),
- 'b' => Ok(WordBoundary(FLAG_EMPTY)),
- 'B' => Ok(WordBoundary(FLAG_NEGATED)),
- '0'|'1'|'2'|'3'|'4'|'5'|'6'|'7' => Ok(try!(self.parse_octal())),
- 'x' => Ok(try!(self.parse_hex())),
- 'p' | 'P' => Ok(try!(self.parse_unicode_name())),
- 'd' | 'D' | 's' | 'S' | 'w' | 'W' => {
- let ranges = perl_unicode_class(c);
- let mut flags = self.flags & FLAG_NOCASE;
- if c.is_uppercase() { flags |= FLAG_NEGATED }
- Ok(Class(ranges, flags))
- }
- _ => {
- self.err(format!("Invalid escape sequence '\\\\{}'",
- c).as_slice())
- }
- }
- }
-
- // Parses a unicode character class name, either of the form \pF where
- // F is a one letter unicode class name or of the form \p{name} where
- // name is the unicode class name.
- // Assumes that \p or \P has been read (and 'p' or 'P' is the current
- // character).
- fn parse_unicode_name(&mut self) -> Result<Ast, Error> {
- let negated = if self.cur() == 'P' { FLAG_NEGATED } else { FLAG_EMPTY };
- let mut name: String;
- if self.peek_is(1, '{') {
- try!(self.expect('{'))
- let closer =
- match self.pos('}') {
- Some(i) => i,
- None => return self.err(format!(
- "Missing '}}' for unclosed '{{' at position {}",
- self.chari).as_slice()),
- };
- if closer - self.chari + 1 == 0 {
- return self.err("No Unicode class name found.")
- }
- name = self.slice(self.chari + 1, closer);
- self.chari = closer;
- } else {
- if self.chari + 1 >= self.chars.len() {
- return self.err("No single letter Unicode class name found.")
- }
- name = self.slice(self.chari + 1, self.chari + 2);
- self.chari += 1;
- }
- match find_class(UNICODE_CLASSES, name.as_slice()) {
- None => {
- return self.err(format!("Could not find Unicode class '{}'",
- name).as_slice())
- }
- Some(ranges) => {
- Ok(Class(ranges, negated | (self.flags & FLAG_NOCASE)))
- }
- }
- }
-
- // Parses an octal number, up to 3 digits.
- // Assumes that \n has been read, where n is the first digit.
- fn parse_octal(&mut self) -> Result<Ast, Error> {
- let start = self.chari;
- let mut end = start + 1;
- let (d2, d3) = (self.peek(1), self.peek(2));
- if d2 >= Some('0') && d2 <= Some('7') {
- try!(self.noteof("expected octal character in [0-7]"))
- end += 1;
- if d3 >= Some('0') && d3 <= Some('7') {
- try!(self.noteof("expected octal character in [0-7]"))
- end += 1;
- }
- }
- let s = self.slice(start, end);
- match num::from_str_radix::<u32>(s.as_slice(), 8) {
- Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
- None => {
- self.err(format!("Could not parse '{}' as octal number.",
- s).as_slice())
- }
- }
- }
-
- // Parse a hex number. Either exactly two digits or anything in {}.
- // Assumes that \x has been read.
- fn parse_hex(&mut self) -> Result<Ast, Error> {
- if !self.peek_is(1, '{') {
- try!(self.expect('{'))
- return self.parse_hex_two()
- }
- let start = self.chari + 2;
- let closer =
- match self.pos('}') {
- None => {
- return self.err(format!("Missing '}}' for unclosed \
- '{{' at position {}",
- start).as_slice())
- }
- Some(i) => i,
- };
- self.chari = closer;
- self.parse_hex_digits(self.slice(start, closer).as_slice())
- }
-
- // Parses a two-digit hex number.
- // Assumes that \xn has been read, where n is the first digit and is the
- // current character.
- // After return, parser will point at the second digit.
- fn parse_hex_two(&mut self) -> Result<Ast, Error> {
- let (start, end) = (self.chari, self.chari + 2);
- let bad = self.slice(start - 2, self.chars.len());
- try!(self.noteof(format!("Invalid hex escape sequence '{}'",
- bad).as_slice()))
- self.parse_hex_digits(self.slice(start, end).as_slice())
- }
-
- // Parses `s` as a hexadecimal number.
- fn parse_hex_digits(&self, s: &str) -> Result<Ast, Error> {
- match num::from_str_radix::<u32>(s, 16) {
- Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
- None => {
- self.err(format!("Could not parse '{}' as hex number.",
- s).as_slice())
- }
- }
- }
-
- // Parses a named capture.
- // Assumes that '(?P<' has been consumed and that the current character
- // is '<'.
- // When done, parser will be at the closing '>' character.
- fn parse_named_capture(&mut self) -> Result<(), Error> {
- try!(self.noteof("a capture name"))
- let closer =
- match self.pos('>') {
- Some(i) => i,
- None => return self.err("Capture name must end with '>'."),
- };
- if closer - self.chari == 0 {
- return self.err("Capture names must have at least 1 character.")
- }
- let name = self.slice(self.chari, closer);
- if !name.as_slice().chars().all(is_valid_cap) {
- return self.err(
- "Capture names can only have underscores, letters and digits.")
- }
- if self.names.contains(&name) {
- return self.err(format!("Duplicate capture group name '{}'.",
- name).as_slice())
- }
- self.names.push(name.clone());
- self.chari = closer;
- self.caps += 1;
- self.stack.push(Paren(self.flags, self.caps, name));
- Ok(())
- }
-
- // Parses non-capture groups and options.
- // Assumes that '(?' has already been consumed and '?' is the current
- // character.
- fn parse_group_opts(&mut self) -> Result<(), Error> {
- if self.peek_is(1, 'P') && self.peek_is(2, '<') {
- try!(self.expect('P')) try!(self.expect('<'))
- return self.parse_named_capture()
- }
- let start = self.chari;
- let mut flags = self.flags;
- let mut sign = 1i;
- let mut saw_flag = false;
- loop {
- try!(self.noteof("expected non-empty set of flags or closing ')'"))
- match self.cur() {
- 'i' => { flags = flags | FLAG_NOCASE; saw_flag = true},
- 'm' => { flags = flags | FLAG_MULTI; saw_flag = true},
- 's' => { flags = flags | FLAG_DOTNL; saw_flag = true},
- 'U' => { flags = flags | FLAG_SWAP_GREED; saw_flag = true},
- '-' => {
- if sign < 0 {
- return self.err(format!(
- "Cannot negate flags twice in '{}'.",
- self.slice(start, self.chari + 1)).as_slice())
- }
- sign = -1;
- saw_flag = false;
- flags = flags ^ flags;
- }
- ':' | ')' => {
- if sign < 0 {
- if !saw_flag {
- return self.err(format!(
- "A valid flag does not follow negation in '{}'",
- self.slice(start, self.chari + 1)).as_slice())
- }
- flags = flags ^ flags;
- }
- if self.cur() == ':' {
- // Save the old flags with the opening paren.
- self.stack.push(Paren(self.flags, 0, "".to_string()));
- }
- self.flags = flags;
- return Ok(())
- }
- _ => return self.err(format!(
- "Unrecognized flag '{}'.", self.cur()).as_slice()),
- }
- }
- }
-
- // Peeks at the next character and returns whether it's ungreedy or not.
- // If it is, then the next character is consumed.
- fn get_next_greedy(&mut self) -> Result<Greed, Error> {
- Ok(if self.peek_is(1, '?') {
- try!(self.expect('?'))
- Ungreedy
- } else {
- Greedy
- }.swap(self.flags & FLAG_SWAP_GREED > 0))
- }
-
- // Searches the stack (starting at the top) until it finds an expression
- // for which `pred` returns true. The index of that expression in the
- // stack is returned.
- // If there's no match, then one of two things happens depending on the
- // values of `allow_start`. When it's true, then `0` will be returned.
- // Otherwise, an error will be returned.
- // Generally, `allow_start` is only true when you're *not* expecting an
- // opening parenthesis.
- fn pos_last(&self, allow_start: bool, pred: |&BuildAst| -> bool)
- -> Result<uint, Error> {
- let from = match self.stack.iter().rev().position(pred) {
- Some(i) => i,
- None => {
- if allow_start {
- self.stack.len()
- } else {
- return self.err("No matching opening parenthesis.")
- }
- }
- };
- // Adjust index since 'from' is for the reversed stack.
- // Also, don't include the '(' or '|'.
- Ok(self.stack.len() - from)
- }
-
- // concat starts at `from` in the parser's stack and concatenates all
- // expressions up to the top of the stack. The resulting concatenation is
- // then pushed on to the stack.
- // Usually `from` corresponds to the position of an opening parenthesis,
- // a '|' (alternation) or the start of the entire expression.
- fn concat(&mut self, from: uint) -> Result<(), Error> {
- let ast = try!(self.build_from(from, concat_flatten));
- self.push(ast);
- Ok(())
- }
-
- // concat starts at `from` in the parser's stack and alternates all
- // expressions up to the top of the stack. The resulting alternation is
- // then pushed on to the stack.
- // Usually `from` corresponds to the position of an opening parenthesis
- // or the start of the entire expression.
- // This will also drop any opening parens or alternation bars found in
- // the intermediate AST.
- fn alternate(&mut self, mut from: uint) -> Result<(), Error> {
- // Unlike in the concatenation case, we want 'build_from' to continue
- // all the way to the opening left paren (so it will be popped off and
- // thrown away). But be careful with overflow---we can't count on the
- // open paren to be there.
- if from > 0 { from = from - 1}
- let ast = try!(self.build_from(from, |l,r| Alt(box l, box r)));
- self.push(ast);
- Ok(())
- }
-
- // build_from combines all AST elements starting at 'from' in the
- // parser's stack using 'mk' to combine them. If any such element is not an
- // AST then it is popped off the stack and ignored.
- fn build_from(&mut self, from: uint, mk: |Ast, Ast| -> Ast)
- -> Result<Ast, Error> {
- if from >= self.stack.len() {
- return self.err("Empty group or alternate not allowed.")
- }
-
- let mut combined = try!(self.pop_ast());
- let mut i = self.stack.len();
- while i > from {
- i = i - 1;
- match self.stack.pop().unwrap() {
- Ast(x) => combined = mk(x, combined),
- _ => {},
- }
- }
- Ok(combined)
- }
-
- fn parse_uint(&self, s: &str) -> Result<uint, Error> {
- match from_str::<uint>(s) {
- Some(i) => Ok(i),
- None => {
- self.err(format!("Expected an unsigned integer but got '{}'.",
- s).as_slice())
- }
- }
- }
-
- fn char_from_u32(&self, n: u32) -> Result<char, Error> {
- match char::from_u32(n) {
- Some(c) => Ok(c),
- None => {
- self.err(format!("Could not decode '{}' to unicode \
- character.",
- n).as_slice())
- }
- }
- }
-
- fn pos(&self, c: char) -> Option<uint> {
- self.chars.iter()
- .skip(self.chari).position(|&c2| c2 == c).map(|i| self.chari + i)
- }
-
- fn err<T>(&self, msg: &str) -> Result<T, Error> {
- Err(Error {
- pos: self.chari,
- msg: msg.to_string(),
- })
- }
-
- fn peek(&self, offset: uint) -> Option<char> {
- if self.chari + offset >= self.chars.len() {
- return None
- }
- Some(*self.chars.get(self.chari + offset))
- }
-
- fn peek_is(&self, offset: uint, is: char) -> bool {
- self.peek(offset) == Some(is)
- }
-
- fn cur(&self) -> char {
- *self.chars.get(self.chari)
- }
-
- fn slice(&self, start: uint, end: uint) -> String {
- str::from_chars(self.chars.as_slice().slice(start, end)).to_string()
- }
-}
-
-// Given an unordered collection of character ranges, combine_ranges returns
-// an ordered sequence of character ranges where no two ranges overlap. They
-// are ordered from least to greatest (using start position).
-fn combine_ranges(unordered: Vec<(char, char)>) -> Vec<(char, char)> {
- // Returns true iff the two character classes overlap or share a boundary.
- // e.g., ('a', 'g') and ('h', 'm') would return true.
- fn should_merge((a, b): (char, char), (x, y): (char, char)) -> bool {
- cmp::max(a, x) as u32 <= cmp::min(b, y) as u32 + 1
- }
-
- // This is currently O(n^2), but I think with sufficient cleverness,
- // it can be reduced to O(n) **if necessary**.
- let mut ordered: Vec<(char, char)> = Vec::with_capacity(unordered.len());
- for (us, ue) in unordered.move_iter() {
- let (mut us, mut ue) = (us, ue);
- assert!(us <= ue);
- let mut which: Option<uint> = None;
- for (i, &(os, oe)) in ordered.iter().enumerate() {
- if should_merge((us, ue), (os, oe)) {
- us = cmp::min(us, os);
- ue = cmp::max(ue, oe);
- which = Some(i);
- break
- }
- }
- match which {
- None => ordered.push((us, ue)),
- Some(i) => *ordered.get_mut(i) = (us, ue),
- }
- }
- ordered.sort();
- ordered
-}
-
-// Constructs a Unicode friendly Perl character class from \d, \s or \w
-// (or any of their negated forms). Note that this does not handle negation.
-fn perl_unicode_class(which: char) -> Vec<(char, char)> {
- match which.to_lowercase() {
- 'd' => Vec::from_slice(PERLD),
- 's' => Vec::from_slice(PERLS),
- 'w' => Vec::from_slice(PERLW),
- _ => unreachable!(),
- }
-}
-
-// Returns a concatenation of two expressions. This also guarantees that a
-// `Cat` expression will never be a direct child of another `Cat` expression.
-fn concat_flatten(x: Ast, y: Ast) -> Ast {
- match (x, y) {
- (Cat(mut xs), Cat(ys)) => { xs.push_all_move(ys); Cat(xs) }
- (Cat(mut xs), ast) => { xs.push(ast); Cat(xs) }
- (ast, Cat(mut xs)) => { xs.unshift(ast); Cat(xs) }
- (ast1, ast2) => Cat(vec!(ast1, ast2)),
- }
-}
-
-pub fn is_punct(c: char) -> bool {
- match c {
- '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' |
- '[' | ']' | '{' | '}' | '^' | '$' => true,
- _ => false,
- }
-}
-
-fn is_valid_cap(c: char) -> bool {
- c == '_' || (c >= '0' && c <= '9')
- || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
-}
-
-fn find_class(classes: NamedClasses, name: &str) -> Option<Vec<(char, char)>> {
- match classes.bsearch(|&(s, _)| s.cmp(&name)) {
- Some(i) => Some(Vec::from_slice(classes[i].val1())),
- None => None,
- }
-}
-
-type Class = &'static [(char, char)];
-type NamedClasses = &'static [(&'static str, Class)];
-
-static ASCII_CLASSES: NamedClasses = &[
- // Classes must be in alphabetical order so that bsearch works.
- // [:alnum:] alphanumeric (== [0-9A-Za-z])
- // [:alpha:] alphabetic (== [A-Za-z])
- // [:ascii:] ASCII (== [\x00-\x7F])
- // [:blank:] blank (== [\t ])
- // [:cntrl:] control (== [\x00-\x1F\x7F])
- // [:digit:] digits (== [0-9])
- // [:graph:] graphical (== [!-~])
- // [:lower:] lower case (== [a-z])
- // [:print:] printable (== [ -~] == [ [:graph:]])
- // [:punct:] punctuation (== [!-/:-@[-`{-~])
- // [:space:] whitespace (== [\t\n\v\f\r ])
- // [:upper:] upper case (== [A-Z])
- // [:word:] word characters (== [0-9A-Za-z_])
- // [:xdigit:] hex digit (== [0-9A-Fa-f])
- // Taken from: http://golang.org/pkg/regex/syntax/
- ("alnum", &[('0', '9'), ('A', 'Z'), ('a', 'z')]),
- ("alpha", &[('A', 'Z'), ('a', 'z')]),
- ("ascii", &[('\x00', '\x7F')]),
- ("blank", &[(' ', ' '), ('\t', '\t')]),
- ("cntrl", &[('\x00', '\x1F'), ('\x7F', '\x7F')]),
- ("digit", &[('0', '9')]),
- ("graph", &[('!', '~')]),
- ("lower", &[('a', 'z')]),
- ("print", &[(' ', '~')]),
- ("punct", &[('!', '/'), (':', '@'), ('[', '`'), ('{', '~')]),
- ("space", &[('\t', '\t'), ('\n', '\n'), ('\x0B', '\x0B'), ('\x0C', '\x0C'),
- ('\r', '\r'), (' ', ' ')]),
- ("upper", &[('A', 'Z')]),
- ("word", &[('0', '9'), ('A', 'Z'), ('a', 'z'), ('_', '_')]),
- ("xdigit", &[('0', '9'), ('A', 'F'), ('a', 'f')]),
-];
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// DO NOT EDIT. Automatically generated by 'src/etc/regex-unicode-tables'
-// on 2014-04-23 00:13:04.445491.
-
-use parse::{Class, NamedClasses};
-
-pub static UNICODE_CLASSES: NamedClasses = &[
-
-("Arabic", &[
- ('\U00000600', '\U00000604'),
- ('\U00000606', '\U0000060b'),
- ('\U0000060d', '\U0000061a'),
- ('\U0000061c', '\U0000061c'),
- ('\U0000061e', '\U0000061e'),
- ('\U00000620', '\U0000063f'),
- ('\U00000641', '\U0000064a'),
- ('\U00000656', '\U0000065f'),
- ('\U0000066a', '\U0000066f'),
- ('\U00000671', '\U000006dc'),
- ('\U000006de', '\U000006ff'),
- ('\U00000750', '\U0000077f'),
- ('\U000008a0', '\U000008a0'),
- ('\U000008a2', '\U000008ac'),
- ('\U000008e4', '\U000008fe'),
- ('\U0000fb50', '\U0000fbc1'),
- ('\U0000fbd3', '\U0000fd3d'),
- ('\U0000fd50', '\U0000fd8f'),
- ('\U0000fd92', '\U0000fdc7'),
- ('\U0000fdf0', '\U0000fdfc'),
- ('\U0000fe70', '\U0000fe74'),
- ('\U0000fe76', '\U0000fefc'),
- ('\U00010e60', '\U00010e7e'),
- ('\U0001ee00', '\U0001ee03'),
- ('\U0001ee05', '\U0001ee1f'),
- ('\U0001ee21', '\U0001ee22'),
- ('\U0001ee24', '\U0001ee24'),
- ('\U0001ee27', '\U0001ee27'),
- ('\U0001ee29', '\U0001ee32'),
- ('\U0001ee34', '\U0001ee37'),
- ('\U0001ee39', '\U0001ee39'),
- ('\U0001ee3b', '\U0001ee3b'),
- ('\U0001ee42', '\U0001ee42'),
- ('\U0001ee47', '\U0001ee47'),
- ('\U0001ee49', '\U0001ee49'),
- ('\U0001ee4b', '\U0001ee4b'),
- ('\U0001ee4d', '\U0001ee4f'),
- ('\U0001ee51', '\U0001ee52'),
- ('\U0001ee54', '\U0001ee54'),
- ('\U0001ee57', '\U0001ee57'),
- ('\U0001ee59', '\U0001ee59'),
- ('\U0001ee5b', '\U0001ee5b'),
- ('\U0001ee5d', '\U0001ee5d'),
- ('\U0001ee5f', '\U0001ee5f'),
- ('\U0001ee61', '\U0001ee62'),
- ('\U0001ee64', '\U0001ee64'),
- ('\U0001ee67', '\U0001ee6a'),
- ('\U0001ee6c', '\U0001ee72'),
- ('\U0001ee74', '\U0001ee77'),
- ('\U0001ee79', '\U0001ee7c'),
- ('\U0001ee7e', '\U0001ee7e'),
- ('\U0001ee80', '\U0001ee89'),
- ('\U0001ee8b', '\U0001ee9b'),
- ('\U0001eea1', '\U0001eea3'),
- ('\U0001eea5', '\U0001eea9'),
- ('\U0001eeab', '\U0001eebb'),
- ('\U0001eef0', '\U0001eef1')
- ]),
-("Armenian", &[
- ('\U00000531', '\U00000556'),
- ('\U00000559', '\U0000055f'),
- ('\U00000561', '\U00000587'),
- ('\U0000058a', '\U0000058a'),
- ('\U0000058f', '\U0000058f'),
- ('\U0000fb13', '\U0000fb17')
- ]),
-("Avestan", &[
- ('\U00010b00', '\U00010b35'),
- ('\U00010b39', '\U00010b3f')
- ]),
-("Balinese", &[
- ('\U00001b00', '\U00001b4b'),
- ('\U00001b50', '\U00001b7c')
- ]),
-("Bamum", &[
- ('\U0000a6a0', '\U0000a6f7'),
- ('\U00016800', '\U00016a38')
- ]),
-("Batak", &[
- ('\U00001bc0', '\U00001bf3'),
- ('\U00001bfc', '\U00001bff')
- ]),
-("Bengali", &[
- ('\U00000981', '\U00000983'),
- ('\U00000985', '\U0000098c'),
- ('\U0000098f', '\U00000990'),
- ('\U00000993', '\U000009a8'),
- ('\U000009aa', '\U000009b0'),
- ('\U000009b2', '\U000009b2'),
- ('\U000009b6', '\U000009b9'),
- ('\U000009bc', '\U000009c4'),
- ('\U000009c7', '\U000009c8'),
- ('\U000009cb', '\U000009ce'),
- ('\U000009d7', '\U000009d7'),
- ('\U000009dc', '\U000009dd'),
- ('\U000009df', '\U000009e3'),
- ('\U000009e6', '\U000009fb')
- ]),
-("Bopomofo", &[
- ('\U000002ea', '\U000002eb'),
- ('\U00003105', '\U0000312d'),
- ('\U000031a0', '\U000031ba')
- ]),
-("Brahmi", &[
- ('\U00011000', '\U0001104d'),
- ('\U00011052', '\U0001106f')
- ]),
-("Braille", &[
- ('\U00002800', '\U000028ff')
- ]),
-("Buginese", &[
- ('\U00001a00', '\U00001a1b'),
- ('\U00001a1e', '\U00001a1f')
- ]),
-("Buhid", &[
- ('\U00001740', '\U00001753')
- ]),
-("C", &[
- ('\U00000000', '\U0000001f'),
- ('\U0000007f', '\U0000009f'),
- ('\U000000ad', '\U000000ad'),
- ('\U00000600', '\U00000604'),
- ('\U0000061c', '\U0000061c'),
- ('\U000006dd', '\U000006dd'),
- ('\U0000070f', '\U0000070f'),
- ('\U0000180e', '\U0000180e'),
- ('\U0000200b', '\U0000200f'),
- ('\U0000202a', '\U0000202e'),
- ('\U00002060', '\U00002064'),
- ('\U00002066', '\U0000206f'),
- ('\U0000e000', '\U0000e000'),
- ('\U0000f8ff', '\U0000f8ff'),
- ('\U0000feff', '\U0000feff'),
- ('\U0000fff9', '\U0000fffb'),
- ('\U000110bd', '\U000110bd'),
- ('\U0001d173', '\U0001d17a'),
- ('\U000e0001', '\U000e0001'),
- ('\U000e0020', '\U000e007f'),
- ('\U000f0000', '\U000f0000'),
- ('\U000ffffd', '\U000ffffd'),
- ('\U00100000', '\U00100000'),
- ('\U0010fffd', '\U0010fffd')
- ]),
-("Canadian_Aboriginal", &[
- ('\U00001400', '\U0000167f'),
- ('\U000018b0', '\U000018f5')
- ]),
-("Carian", &[
- ('\U000102a0', '\U000102d0')
- ]),
-("Cc", &[
- ('\U00000000', '\U0000001f'),
- ('\U0000007f', '\U0000009f')
- ]),
-("Cf", &[
- ('\U000000ad', '\U000000ad'),
- ('\U00000600', '\U00000604'),
- ('\U0000061c', '\U0000061c'),
- ('\U000006dd', '\U000006dd'),
- ('\U0000070f', '\U0000070f'),
- ('\U0000180e', '\U0000180e'),
- ('\U0000200b', '\U0000200f'),
- ('\U0000202a', '\U0000202e'),
- ('\U00002060', '\U00002064'),
- ('\U00002066', '\U0000206f'),
- ('\U0000feff', '\U0000feff'),
- ('\U0000fff9', '\U0000fffb'),
- ('\U000110bd', '\U000110bd'),
- ('\U0001d173', '\U0001d17a'),
- ('\U000e0001', '\U000e0001'),
- ('\U000e0020', '\U000e007f')
- ]),
-("Chakma", &[
- ('\U00011100', '\U00011134'),
- ('\U00011136', '\U00011143')
- ]),
-("Cham", &[
- ('\U0000aa00', '\U0000aa36'),
- ('\U0000aa40', '\U0000aa4d'),
- ('\U0000aa50', '\U0000aa59'),
- ('\U0000aa5c', '\U0000aa5f')
- ]),
-("Cherokee", &[
- ('\U000013a0', '\U000013f4')
- ]),
-("Co", &[
- ('\U0000e000', '\U0000e000'),
- ('\U0000f8ff', '\U0000f8ff'),
- ('\U000f0000', '\U000f0000'),
- ('\U000ffffd', '\U000ffffd'),
- ('\U00100000', '\U00100000'),
- ('\U0010fffd', '\U0010fffd')
- ]),
-("Common", &[
- ('\U00000000', '\U00000040'),
- ('\U0000005b', '\U00000060'),
- ('\U0000007b', '\U000000a9'),
- ('\U000000ab', '\U000000b9'),
- ('\U000000bb', '\U000000bf'),
- ('\U000000d7', '\U000000d7'),
- ('\U000000f7', '\U000000f7'),
- ('\U000002b9', '\U000002df'),
- ('\U000002e5', '\U000002e9'),
- ('\U000002ec', '\U000002ff'),
- ('\U00000374', '\U00000374'),
- ('\U0000037e', '\U0000037e'),
- ('\U00000385', '\U00000385'),
- ('\U00000387', '\U00000387'),
- ('\U00000589', '\U00000589'),
- ('\U0000060c', '\U0000060c'),
- ('\U0000061b', '\U0000061b'),
- ('\U0000061f', '\U0000061f'),
- ('\U00000640', '\U00000640'),
- ('\U00000660', '\U00000669'),
- ('\U000006dd', '\U000006dd'),
- ('\U00000964', '\U00000965'),
- ('\U00000e3f', '\U00000e3f'),
- ('\U00000fd5', '\U00000fd8'),
- ('\U000010fb', '\U000010fb'),
- ('\U000016eb', '\U000016ed'),
- ('\U00001735', '\U00001736'),
- ('\U00001802', '\U00001803'),
- ('\U00001805', '\U00001805'),
- ('\U00001cd3', '\U00001cd3'),
- ('\U00001ce1', '\U00001ce1'),
- ('\U00001ce9', '\U00001cec'),
- ('\U00001cee', '\U00001cf3'),
- ('\U00001cf5', '\U00001cf6'),
- ('\U00002000', '\U0000200b'),
- ('\U0000200e', '\U00002064'),
- ('\U00002066', '\U00002070'),
- ('\U00002074', '\U0000207e'),
- ('\U00002080', '\U0000208e'),
- ('\U000020a0', '\U000020ba'),
- ('\U00002100', '\U00002125'),
- ('\U00002127', '\U00002129'),
- ('\U0000212c', '\U00002131'),
- ('\U00002133', '\U0000214d'),
- ('\U0000214f', '\U0000215f'),
- ('\U00002189', '\U00002189'),
- ('\U00002190', '\U000023f3'),
- ('\U00002400', '\U00002426'),
- ('\U00002440', '\U0000244a'),
- ('\U00002460', '\U000026ff'),
- ('\U00002701', '\U000027ff'),
- ('\U00002900', '\U00002b4c'),
- ('\U00002b50', '\U00002b59'),
- ('\U00002e00', '\U00002e3b'),
- ('\U00002ff0', '\U00002ffb'),
- ('\U00003000', '\U00003004'),
- ('\U00003006', '\U00003006'),
- ('\U00003008', '\U00003020'),
- ('\U00003030', '\U00003037'),
- ('\U0000303c', '\U0000303f'),
- ('\U0000309b', '\U0000309c'),
- ('\U000030a0', '\U000030a0'),
- ('\U000030fb', '\U000030fc'),
- ('\U00003190', '\U0000319f'),
- ('\U000031c0', '\U000031e3'),
- ('\U00003220', '\U0000325f'),
- ('\U0000327f', '\U000032cf'),
- ('\U00003358', '\U000033ff'),
- ('\U00004dc0', '\U00004dff'),
- ('\U0000a700', '\U0000a721'),
- ('\U0000a788', '\U0000a78a'),
- ('\U0000a830', '\U0000a839'),
- ('\U0000a9cf', '\U0000a9cf'),
- ('\U0000fd3e', '\U0000fd3f'),
- ('\U0000fdfd', '\U0000fdfd'),
- ('\U0000fe10', '\U0000fe19'),
- ('\U0000fe30', '\U0000fe52'),
- ('\U0000fe54', '\U0000fe66'),
- ('\U0000fe68', '\U0000fe6b'),
- ('\U0000feff', '\U0000feff'),
- ('\U0000ff01', '\U0000ff20'),
- ('\U0000ff3b', '\U0000ff40'),
- ('\U0000ff5b', '\U0000ff65'),
- ('\U0000ff70', '\U0000ff70'),
- ('\U0000ff9e', '\U0000ff9f'),
- ('\U0000ffe0', '\U0000ffe6'),
- ('\U0000ffe8', '\U0000ffee'),
- ('\U0000fff9', '\U0000fffd'),
- ('\U00010100', '\U00010102'),
- ('\U00010107', '\U00010133'),
- ('\U00010137', '\U0001013f'),
- ('\U00010190', '\U0001019b'),
- ('\U000101d0', '\U000101fc'),
- ('\U0001d000', '\U0001d0f5'),
- ('\U0001d100', '\U0001d126'),
- ('\U0001d129', '\U0001d166'),
- ('\U0001d16a', '\U0001d17a'),
- ('\U0001d183', '\U0001d184'),
- ('\U0001d18c', '\U0001d1a9'),
- ('\U0001d1ae', '\U0001d1dd'),
- ('\U0001d300', '\U0001d356'),
- ('\U0001d360', '\U0001d371'),
- ('\U0001d400', '\U0001d454'),
- ('\U0001d456', '\U0001d49c'),
- ('\U0001d49e', '\U0001d49f'),
- ('\U0001d4a2', '\U0001d4a2'),
- ('\U0001d4a5', '\U0001d4a6'),
- ('\U0001d4a9', '\U0001d4ac'),
- ('\U0001d4ae', '\U0001d4b9'),
- ('\U0001d4bb', '\U0001d4bb'),
- ('\U0001d4bd', '\U0001d4c3'),
- ('\U0001d4c5', '\U0001d505'),
- ('\U0001d507', '\U0001d50a'),
- ('\U0001d50d', '\U0001d514'),
- ('\U0001d516', '\U0001d51c'),
- ('\U0001d51e', '\U0001d539'),
- ('\U0001d53b', '\U0001d53e'),
- ('\U0001d540', '\U0001d544'),
- ('\U0001d546', '\U0001d546'),
- ('\U0001d54a', '\U0001d550'),
- ('\U0001d552', '\U0001d6a5'),
- ('\U0001d6a8', '\U0001d7cb'),
- ('\U0001d7ce', '\U0001d7ff'),
- ('\U0001f000', '\U0001f02b'),
- ('\U0001f030', '\U0001f093'),
- ('\U0001f0a0', '\U0001f0ae'),
- ('\U0001f0b1', '\U0001f0be'),
- ('\U0001f0c1', '\U0001f0cf'),
- ('\U0001f0d1', '\U0001f0df'),
- ('\U0001f100', '\U0001f10a'),
- ('\U0001f110', '\U0001f12e'),
- ('\U0001f130', '\U0001f16b'),
- ('\U0001f170', '\U0001f19a'),
- ('\U0001f1e6', '\U0001f1ff'),
- ('\U0001f201', '\U0001f202'),
- ('\U0001f210', '\U0001f23a'),
- ('\U0001f240', '\U0001f248'),
- ('\U0001f250', '\U0001f251'),
- ('\U0001f300', '\U0001f320'),
- ('\U0001f330', '\U0001f335'),
- ('\U0001f337', '\U0001f37c'),
- ('\U0001f380', '\U0001f393'),
- ('\U0001f3a0', '\U0001f3c4'),
- ('\U0001f3c6', '\U0001f3ca'),
- ('\U0001f3e0', '\U0001f3f0'),
- ('\U0001f400', '\U0001f43e'),
- ('\U0001f440', '\U0001f440'),
- ('\U0001f442', '\U0001f4f7'),
- ('\U0001f4f9', '\U0001f4fc'),
- ('\U0001f500', '\U0001f53d'),
- ('\U0001f540', '\U0001f543'),
- ('\U0001f550', '\U0001f567'),
- ('\U0001f5fb', '\U0001f640'),
- ('\U0001f645', '\U0001f64f'),
- ('\U0001f680', '\U0001f6c5'),
- ('\U0001f700', '\U0001f773'),
- ('\U000e0001', '\U000e0001'),
- ('\U000e0020', '\U000e007f')
- ]),
-("Coptic", &[
- ('\U000003e2', '\U000003ef'),
- ('\U00002c80', '\U00002cf3'),
- ('\U00002cf9', '\U00002cff')
- ]),
-("Cuneiform", &[
- ('\U00012000', '\U0001236e'),
- ('\U00012400', '\U00012462'),
- ('\U00012470', '\U00012473')
- ]),
-("Cypriot", &[
- ('\U00010800', '\U00010805'),
- ('\U00010808', '\U00010808'),
- ('\U0001080a', '\U00010835'),
- ('\U00010837', '\U00010838'),
- ('\U0001083c', '\U0001083c'),
- ('\U0001083f', '\U0001083f')
- ]),
-("Cyrillic", &[
- ('\U00000400', '\U00000484'),
- ('\U00000487', '\U00000527'),
- ('\U00001d2b', '\U00001d2b'),
- ('\U00001d78', '\U00001d78'),
- ('\U00002de0', '\U00002dff'),
- ('\U0000a640', '\U0000a697'),
- ('\U0000a69f', '\U0000a69f')
- ]),
-("Deseret", &[
- ('\U00010400', '\U0001044f')
- ]),
-("Devanagari", &[
- ('\U00000900', '\U00000950'),
- ('\U00000953', '\U00000963'),
- ('\U00000966', '\U00000977'),
- ('\U00000979', '\U0000097f'),
- ('\U0000a8e0', '\U0000a8fb')
- ]),
-("Egyptian_Hieroglyphs", &[
- ('\U00013000', '\U0001342e')
- ]),
-("Ethiopic", &[
- ('\U00001200', '\U00001248'),
- ('\U0000124a', '\U0000124d'),
- ('\U00001250', '\U00001256'),
- ('\U00001258', '\U00001258'),
- ('\U0000125a', '\U0000125d'),
- ('\U00001260', '\U00001288'),
- ('\U0000128a', '\U0000128d'),
- ('\U00001290', '\U000012b0'),
- ('\U000012b2', '\U000012b5'),
- ('\U000012b8', '\U000012be'),
- ('\U000012c0', '\U000012c0'),
- ('\U000012c2', '\U000012c5'),
- ('\U000012c8', '\U000012d6'),
- ('\U000012d8', '\U00001310'),
- ('\U00001312', '\U00001315'),
- ('\U00001318', '\U0000135a'),
- ('\U0000135d', '\U0000137c'),
- ('\U00001380', '\U00001399'),
- ('\U00002d80', '\U00002d96'),
- ('\U00002da0', '\U00002da6'),
- ('\U00002da8', '\U00002dae'),
- ('\U00002db0', '\U00002db6'),
- ('\U00002db8', '\U00002dbe'),
- ('\U00002dc0', '\U00002dc6'),
- ('\U00002dc8', '\U00002dce'),
- ('\U00002dd0', '\U00002dd6'),
- ('\U00002dd8', '\U00002dde'),
- ('\U0000ab01', '\U0000ab06'),
- ('\U0000ab09', '\U0000ab0e'),
- ('\U0000ab11', '\U0000ab16'),
- ('\U0000ab20', '\U0000ab26'),
- ('\U0000ab28', '\U0000ab2e')
- ]),
-("Georgian", &[
- ('\U000010a0', '\U000010c5'),
- ('\U000010c7', '\U000010c7'),
- ('\U000010cd', '\U000010cd'),
- ('\U000010d0', '\U000010fa'),
- ('\U000010fc', '\U000010ff'),
- ('\U00002d00', '\U00002d25'),
- ('\U00002d27', '\U00002d27'),
- ('\U00002d2d', '\U00002d2d')
- ]),
-("Glagolitic", &[
- ('\U00002c00', '\U00002c2e'),
- ('\U00002c30', '\U00002c5e')
- ]),
-("Gothic", &[
- ('\U00010330', '\U0001034a')
- ]),
-("Greek", &[
- ('\U00000370', '\U00000373'),
- ('\U00000375', '\U00000377'),
- ('\U0000037a', '\U0000037d'),
- ('\U00000384', '\U00000384'),
- ('\U00000386', '\U00000386'),
- ('\U00000388', '\U0000038a'),
- ('\U0000038c', '\U0000038c'),
- ('\U0000038e', '\U000003a1'),
- ('\U000003a3', '\U000003e1'),
- ('\U000003f0', '\U000003ff'),
- ('\U00001d26', '\U00001d2a'),
- ('\U00001d5d', '\U00001d61'),
- ('\U00001d66', '\U00001d6a'),
- ('\U00001dbf', '\U00001dbf'),
- ('\U00001f00', '\U00001f15'),
- ('\U00001f18', '\U00001f1d'),
- ('\U00001f20', '\U00001f45'),
- ('\U00001f48', '\U00001f4d'),
- ('\U00001f50', '\U00001f57'),
- ('\U00001f59', '\U00001f59'),
- ('\U00001f5b', '\U00001f5b'),
- ('\U00001f5d', '\U00001f5d'),
- ('\U00001f5f', '\U00001f7d'),
- ('\U00001f80', '\U00001fb4'),
- ('\U00001fb6', '\U00001fc4'),
- ('\U00001fc6', '\U00001fd3'),
- ('\U00001fd6', '\U00001fdb'),
- ('\U00001fdd', '\U00001fef'),
- ('\U00001ff2', '\U00001ff4'),
- ('\U00001ff6', '\U00001ffe'),
- ('\U00002126', '\U00002126'),
- ('\U00010140', '\U0001018a'),
- ('\U0001d200', '\U0001d245')
- ]),
-("Gujarati", &[
- ('\U00000a81', '\U00000a83'),
- ('\U00000a85', '\U00000a8d'),
- ('\U00000a8f', '\U00000a91'),
- ('\U00000a93', '\U00000aa8'),
- ('\U00000aaa', '\U00000ab0'),
- ('\U00000ab2', '\U00000ab3'),
- ('\U00000ab5', '\U00000ab9'),
- ('\U00000abc', '\U00000ac5'),
- ('\U00000ac7', '\U00000ac9'),
- ('\U00000acb', '\U00000acd'),
- ('\U00000ad0', '\U00000ad0'),
- ('\U00000ae0', '\U00000ae3'),
- ('\U00000ae6', '\U00000af1')
- ]),
-("Gurmukhi", &[
- ('\U00000a01', '\U00000a03'),
- ('\U00000a05', '\U00000a0a'),
- ('\U00000a0f', '\U00000a10'),
- ('\U00000a13', '\U00000a28'),
- ('\U00000a2a', '\U00000a30'),
- ('\U00000a32', '\U00000a33'),
- ('\U00000a35', '\U00000a36'),
- ('\U00000a38', '\U00000a39'),
- ('\U00000a3c', '\U00000a3c'),
- ('\U00000a3e', '\U00000a42'),
- ('\U00000a47', '\U00000a48'),
- ('\U00000a4b', '\U00000a4d'),
- ('\U00000a51', '\U00000a51'),
- ('\U00000a59', '\U00000a5c'),
- ('\U00000a5e', '\U00000a5e'),
- ('\U00000a66', '\U00000a75')
- ]),
-("Han", &[
- ('\U00002e80', '\U00002e99'),
- ('\U00002e9b', '\U00002ef3'),
- ('\U00002f00', '\U00002fd5'),
- ('\U00003005', '\U00003005'),
- ('\U00003007', '\U00003007'),
- ('\U00003021', '\U00003029'),
- ('\U00003038', '\U0000303b'),
- ('\U00003400', '\U00004db5'),
- ('\U00004e00', '\U00009fcc'),
- ('\U0000f900', '\U0000fa6d'),
- ('\U0000fa70', '\U0000fad9'),
- ('\U00020000', '\U0002a6d6'),
- ('\U0002a700', '\U0002b734'),
- ('\U0002b740', '\U0002b81d'),
- ('\U0002f800', '\U0002fa1d')
- ]),
-("Hangul", &[
- ('\U00001100', '\U000011ff'),
- ('\U0000302e', '\U0000302f'),
- ('\U00003131', '\U0000318e'),
- ('\U00003200', '\U0000321e'),
- ('\U00003260', '\U0000327e'),
- ('\U0000a960', '\U0000a97c'),
- ('\U0000ac00', '\U0000d7a3'),
- ('\U0000d7b0', '\U0000d7c6'),
- ('\U0000d7cb', '\U0000d7fb'),
- ('\U0000ffa0', '\U0000ffbe'),
- ('\U0000ffc2', '\U0000ffc7'),
- ('\U0000ffca', '\U0000ffcf'),
- ('\U0000ffd2', '\U0000ffd7'),
- ('\U0000ffda', '\U0000ffdc')
- ]),
-("Hanunoo", &[
- ('\U00001720', '\U00001734')
- ]),
-("Hebrew", &[
- ('\U00000591', '\U000005c7'),
- ('\U000005d0', '\U000005ea'),
- ('\U000005f0', '\U000005f4'),
- ('\U0000fb1d', '\U0000fb36'),
- ('\U0000fb38', '\U0000fb3c'),
- ('\U0000fb3e', '\U0000fb3e'),
- ('\U0000fb40', '\U0000fb41'),
- ('\U0000fb43', '\U0000fb44'),
- ('\U0000fb46', '\U0000fb4f')
- ]),
-("Hiragana", &[
- ('\U00003041', '\U00003096'),
- ('\U0000309d', '\U0000309f'),
- ('\U0001b001', '\U0001b001'),
- ('\U0001f200', '\U0001f200')
- ]),
-("Imperial_Aramaic", &[
- ('\U00010840', '\U00010855'),
- ('\U00010857', '\U0001085f')
- ]),
-("Inherited", &[
- ('\U00000300', '\U0000036f'),
- ('\U00000485', '\U00000486'),
- ('\U0000064b', '\U00000655'),
- ('\U00000670', '\U00000670'),
- ('\U00000951', '\U00000952'),
- ('\U00001cd0', '\U00001cd2'),
- ('\U00001cd4', '\U00001ce0'),
- ('\U00001ce2', '\U00001ce8'),
- ('\U00001ced', '\U00001ced'),
- ('\U00001cf4', '\U00001cf4'),
- ('\U00001dc0', '\U00001de6'),
- ('\U00001dfc', '\U00001dff'),
- ('\U0000200c', '\U0000200d'),
- ('\U000020d0', '\U000020f0'),
- ('\U0000302a', '\U0000302d'),
- ('\U00003099', '\U0000309a'),
- ('\U0000fe00', '\U0000fe0f'),
- ('\U0000fe20', '\U0000fe26'),
- ('\U000101fd', '\U000101fd'),
- ('\U0001d167', '\U0001d169'),
- ('\U0001d17b', '\U0001d182'),
- ('\U0001d185', '\U0001d18b'),
- ('\U0001d1aa', '\U0001d1ad'),
- ('\U000e0100', '\U000e01ef')
- ]),
-("Inscriptional_Pahlavi", &[
- ('\U00010b60', '\U00010b72'),
- ('\U00010b78', '\U00010b7f')
- ]),
-("Inscriptional_Parthian", &[
- ('\U00010b40', '\U00010b55'),
- ('\U00010b58', '\U00010b5f')
- ]),
-("Javanese", &[
- ('\U0000a980', '\U0000a9cd'),
- ('\U0000a9d0', '\U0000a9d9'),
- ('\U0000a9de', '\U0000a9df')
- ]),
-("Kaithi", &[
- ('\U00011080', '\U000110c1')
- ]),
-("Kannada", &[
- ('\U00000c82', '\U00000c83'),
- ('\U00000c85', '\U00000c8c'),
- ('\U00000c8e', '\U00000c90'),
- ('\U00000c92', '\U00000ca8'),
- ('\U00000caa', '\U00000cb3'),
- ('\U00000cb5', '\U00000cb9'),
- ('\U00000cbc', '\U00000cc4'),
- ('\U00000cc6', '\U00000cc8'),
- ('\U00000cca', '\U00000ccd'),
- ('\U00000cd5', '\U00000cd6'),
- ('\U00000cde', '\U00000cde'),
- ('\U00000ce0', '\U00000ce3'),
- ('\U00000ce6', '\U00000cef'),
- ('\U00000cf1', '\U00000cf2')
- ]),
-("Katakana", &[
- ('\U000030a1', '\U000030fa'),
- ('\U000030fd', '\U000030ff'),
- ('\U000031f0', '\U000031ff'),
- ('\U000032d0', '\U000032fe'),
- ('\U00003300', '\U00003357'),
- ('\U0000ff66', '\U0000ff6f'),
- ('\U0000ff71', '\U0000ff9d'),
- ('\U0001b000', '\U0001b000')
- ]),
-("Kayah_Li", &[
- ('\U0000a900', '\U0000a92f')
- ]),
-("Kharoshthi", &[
- ('\U00010a00', '\U00010a03'),
- ('\U00010a05', '\U00010a06'),
- ('\U00010a0c', '\U00010a13'),
- ('\U00010a15', '\U00010a17'),
- ('\U00010a19', '\U00010a33'),
- ('\U00010a38', '\U00010a3a'),
- ('\U00010a3f', '\U00010a47'),
- ('\U00010a50', '\U00010a58')
- ]),
-("Khmer", &[
- ('\U00001780', '\U000017dd'),
- ('\U000017e0', '\U000017e9'),
- ('\U000017f0', '\U000017f9'),
- ('\U000019e0', '\U000019ff')
- ]),
-("L", &[
- ('\U00000041', '\U0000005a'),
- ('\U00000061', '\U0000007a'),
- ('\U000000aa', '\U000000aa'),
- ('\U000000b5', '\U000000b5'),
- ('\U000000ba', '\U000000ba'),
- ('\U000000c0', '\U000000d6'),
- ('\U000000d8', '\U000000f6'),
- ('\U000000f8', '\U000002c1'),
- ('\U000002c6', '\U000002d1'),
- ('\U000002e0', '\U000002e4'),
- ('\U000002ec', '\U000002ec'),
- ('\U000002ee', '\U000002ee'),
- ('\U00000370', '\U00000374'),
- ('\U00000376', '\U00000377'),
- ('\U0000037a', '\U0000037d'),
- ('\U00000386', '\U00000386'),
- ('\U00000388', '\U0000038a'),
- ('\U0000038c', '\U0000038c'),
- ('\U0000038e', '\U000003a1'),
- ('\U000003a3', '\U000003f5'),
- ('\U000003f7', '\U00000481'),
- ('\U0000048a', '\U00000527'),
- ('\U00000531', '\U00000556'),
- ('\U00000559', '\U00000559'),
- ('\U00000561', '\U00000587'),
- ('\U000005d0', '\U000005ea'),
- ('\U000005f0', '\U000005f2'),
- ('\U00000620', '\U0000064a'),
- ('\U0000066e', '\U0000066f'),
- ('\U00000671', '\U000006d3'),
- ('\U000006d5', '\U000006d5'),
- ('\U000006e5', '\U000006e6'),
- ('\U000006ee', '\U000006ef'),
- ('\U000006fa', '\U000006fc'),
- ('\U000006ff', '\U000006ff'),
- ('\U00000710', '\U00000710'),
- ('\U00000712', '\U0000072f'),
- ('\U0000074d', '\U000007a5'),
- ('\U000007b1', '\U000007b1'),
- ('\U000007ca', '\U000007ea'),
- ('\U000007f4', '\U000007f5'),
- ('\U000007fa', '\U000007fa'),
- ('\U00000800', '\U00000815'),
- ('\U0000081a', '\U0000081a'),
- ('\U00000824', '\U00000824'),
- ('\U00000828', '\U00000828'),
- ('\U00000840', '\U00000858'),
- ('\U000008a0', '\U000008a0'),
- ('\U000008a2', '\U000008ac'),
- ('\U00000904', '\U00000939'),
- ('\U0000093d', '\U0000093d'),
- ('\U00000950', '\U00000950'),
- ('\U00000958', '\U00000961'),
- ('\U00000971', '\U00000977'),
- ('\U00000979', '\U0000097f'),
- ('\U00000985', '\U0000098c'),
- ('\U0000098f', '\U00000990'),
- ('\U00000993', '\U000009a8'),
- ('\U000009aa', '\U000009b0'),
- ('\U000009b2', '\U000009b2'),
- ('\U000009b6', '\U000009b9'),
- ('\U000009bd', '\U000009bd'),
- ('\U000009ce', '\U000009ce'),
- ('\U000009dc', '\U000009dd'),
- ('\U000009df', '\U000009e1'),
- ('\U000009f0', '\U000009f1'),
- ('\U00000a05', '\U00000a0a'),
- ('\U00000a0f', '\U00000a10'),
- ('\U00000a13', '\U00000a28'),
- ('\U00000a2a', '\U00000a30'),
- ('\U00000a32', '\U00000a33'),
- ('\U00000a35', '\U00000a36'),
- ('\U00000a38', '\U00000a39'),
- ('\U00000a59', '\U00000a5c'),
- ('\U00000a5e', '\U00000a5e'),
- ('\U00000a72', '\U00000a74'),
- ('\U00000a85', '\U00000a8d'),
- ('\U00000a8f', '\U00000a91'),
- ('\U00000a93', '\U00000aa8'),
- ('\U00000aaa', '\U00000ab0'),
- ('\U00000ab2', '\U00000ab3'),
- ('\U00000ab5', '\U00000ab9'),
- ('\U00000abd', '\U00000abd'),
- ('\U00000ad0', '\U00000ad0'),
- ('\U00000ae0', '\U00000ae1'),
- ('\U00000b05', '\U00000b0c'),
- ('\U00000b0f', '\U00000b10'),
- ('\U00000b13', '\U00000b28'),
- ('\U00000b2a', '\U00000b30'),
- ('\U00000b32', '\U00000b33'),
- ('\U00000b35', '\U00000b39'),
- ('\U00000b3d', '\U00000b3d'),
- ('\U00000b5c', '\U00000b5d'),
- ('\U00000b5f', '\U00000b61'),
- ('\U00000b71', '\U00000b71'),
- ('\U00000b83', '\U00000b83'),
- ('\U00000b85', '\U00000b8a'),
- ('\U00000b8e', '\U00000b90'),
- ('\U00000b92', '\U00000b95'),
- ('\U00000b99', '\U00000b9a'),
- ('\U00000b9c', '\U00000b9c'),
- ('\U00000b9e', '\U00000b9f'),
- ('\U00000ba3', '\U00000ba4'),
- ('\U00000ba8', '\U00000baa'),
- ('\U00000bae', '\U00000bb9'),
- ('\U00000bd0', '\U00000bd0'),
- ('\U00000c05', '\U00000c0c'),
- ('\U00000c0e', '\U00000c10'),
- ('\U00000c12', '\U00000c28'),
- ('\U00000c2a', '\U00000c33'),
- ('\U00000c35', '\U00000c39'),
- ('\U00000c3d', '\U00000c3d'),
- ('\U00000c58', '\U00000c59'),
- ('\U00000c60', '\U00000c61'),
- ('\U00000c85', '\U00000c8c'),
- ('\U00000c8e', '\U00000c90'),
- ('\U00000c92', '\U00000ca8'),
- ('\U00000caa', '\U00000cb3'),
- ('\U00000cb5', '\U00000cb9'),
- ('\U00000cbd', '\U00000cbd'),
- ('\U00000cde', '\U00000cde'),
- ('\U00000ce0', '\U00000ce1'),
- ('\U00000cf1', '\U00000cf2'),
- ('\U00000d05', '\U00000d0c'),
- ('\U00000d0e', '\U00000d10'),
- ('\U00000d12', '\U00000d3a'),
- ('\U00000d3d', '\U00000d3d'),
- ('\U00000d4e', '\U00000d4e'),
- ('\U00000d60', '\U00000d61'),
- ('\U00000d7a', '\U00000d7f'),
- ('\U00000d85', '\U00000d96'),
- ('\U00000d9a', '\U00000db1'),
- ('\U00000db3', '\U00000dbb'),
- ('\U00000dbd', '\U00000dbd'),
- ('\U00000dc0', '\U00000dc6'),
- ('\U00000e01', '\U00000e30'),
- ('\U00000e32', '\U00000e33'),
- ('\U00000e40', '\U00000e46'),
- ('\U00000e81', '\U00000e82'),
- ('\U00000e84', '\U00000e84'),
- ('\U00000e87', '\U00000e88'),
- ('\U00000e8a', '\U00000e8a'),
- ('\U00000e8d', '\U00000e8d'),
- ('\U00000e94', '\U00000e97'),
- ('\U00000e99', '\U00000e9f'),
- ('\U00000ea1', '\U00000ea3'),
- ('\U00000ea5', '\U00000ea5'),
- ('\U00000ea7', '\U00000ea7'),
- ('\U00000eaa', '\U00000eab'),
- ('\U00000ead', '\U00000eb0'),
- ('\U00000eb2', '\U00000eb3'),
- ('\U00000ebd', '\U00000ebd'),
- ('\U00000ec0', '\U00000ec4'),
- ('\U00000ec6', '\U00000ec6'),
- ('\U00000edc', '\U00000edf'),
- ('\U00000f00', '\U00000f00'),
- ('\U00000f40', '\U00000f47'),
- ('\U00000f49', '\U00000f6c'),
- ('\U00000f88', '\U00000f8c'),
- ('\U00001000', '\U0000102a'),
- ('\U0000103f', '\U0000103f'),
- ('\U00001050', '\U00001055'),
- ('\U0000105a', '\U0000105d'),
- ('\U00001061', '\U00001061'),
- ('\U00001065', '\U00001066'),
- ('\U0000106e', '\U00001070'),
- ('\U00001075', '\U00001081'),
- ('\U0000108e', '\U0000108e'),
- ('\U000010a0', '\U000010c5'),
- ('\U000010c7', '\U000010c7'),
- ('\U000010cd', '\U000010cd'),
- ('\U000010d0', '\U000010fa'),
- ('\U000010fc', '\U00001248'),
- ('\U0000124a', '\U0000124d'),
- ('\U00001250', '\U00001256'),
- ('\U00001258', '\U00001258'),
- ('\U0000125a', '\U0000125d'),
- ('\U00001260', '\U00001288'),
- ('\U0000128a', '\U0000128d'),
- ('\U00001290', '\U000012b0'),
- ('\U000012b2', '\U000012b5'),
- ('\U000012b8', '\U000012be'),
- ('\U000012c0', '\U000012c0'),
- ('\U000012c2', '\U000012c5'),
- ('\U000012c8', '\U000012d6'),
- ('\U000012d8', '\U00001310'),
- ('\U00001312', '\U00001315'),
- ('\U00001318', '\U0000135a'),
- ('\U00001380', '\U0000138f'),
- ('\U000013a0', '\U000013f4'),
- ('\U00001401', '\U0000166c'),
- ('\U0000166f', '\U0000167f'),
- ('\U00001681', '\U0000169a'),
- ('\U000016a0', '\U000016ea'),
- ('\U00001700', '\U0000170c'),
- ('\U0000170e', '\U00001711'),
- ('\U00001720', '\U00001731'),
- ('\U00001740', '\U00001751'),
- ('\U00001760', '\U0000176c'),
- ('\U0000176e', '\U00001770'),
- ('\U00001780', '\U000017b3'),
- ('\U000017d7', '\U000017d7'),
- ('\U000017dc', '\U000017dc'),
- ('\U00001820', '\U00001877'),
- ('\U00001880', '\U000018a8'),
- ('\U000018aa', '\U000018aa'),
- ('\U000018b0', '\U000018f5'),
- ('\U00001900', '\U0000191c'),
- ('\U00001950', '\U0000196d'),
- ('\U00001970', '\U00001974'),
- ('\U00001980', '\U000019ab'),
- ('\U000019c1', '\U000019c7'),
- ('\U00001a00', '\U00001a16'),
- ('\U00001a20', '\U00001a54'),
- ('\U00001aa7', '\U00001aa7'),
- ('\U00001b05', '\U00001b33'),
- ('\U00001b45', '\U00001b4b'),
- ('\U00001b83', '\U00001ba0'),
- ('\U00001bae', '\U00001baf'),
- ('\U00001bba', '\U00001be5'),
- ('\U00001c00', '\U00001c23'),
- ('\U00001c4d', '\U00001c4f'),
- ('\U00001c5a', '\U00001c7d'),
- ('\U00001ce9', '\U00001cec'),
- ('\U00001cee', '\U00001cf1'),
- ('\U00001cf5', '\U00001cf6'),
- ('\U00001d00', '\U00001dbf'),
- ('\U00001e00', '\U00001f15'),
- ('\U00001f18', '\U00001f1d'),
- ('\U00001f20', '\U00001f45'),
- ('\U00001f48', '\U00001f4d'),
- ('\U00001f50', '\U00001f57'),
- ('\U00001f59', '\U00001f59'),
- ('\U00001f5b', '\U00001f5b'),
- ('\U00001f5d', '\U00001f5d'),
- ('\U00001f5f', '\U00001f7d'),
- ('\U00001f80', '\U00001fb4'),
- ('\U00001fb6', '\U00001fbc'),
- ('\U00001fbe', '\U00001fbe'),
- ('\U00001fc2', '\U00001fc4'),
- ('\U00001fc6', '\U00001fcc'),
- ('\U00001fd0', '\U00001fd3'),
- ('\U00001fd6', '\U00001fdb'),
- ('\U00001fe0', '\U00001fec'),
- ('\U00001ff2', '\U00001ff4'),
- ('\U00001ff6', '\U00001ffc'),
- ('\U00002071', '\U00002071'),
- ('\U0000207f', '\U0000207f'),
- ('\U00002090', '\U0000209c'),
- ('\U00002102', '\U00002102'),
- ('\U00002107', '\U00002107'),
- ('\U0000210a', '\U00002113'),
- ('\U00002115', '\U00002115'),
- ('\U00002119', '\U0000211d'),
- ('\U00002124', '\U00002124'),
- ('\U00002126', '\U00002126'),
- ('\U00002128', '\U00002128'),
- ('\U0000212a', '\U0000212d'),
- ('\U0000212f', '\U00002139'),
- ('\U0000213c', '\U0000213f'),
- ('\U00002145', '\U00002149'),
- ('\U0000214e', '\U0000214e'),
- ('\U00002183', '\U00002184'),
- ('\U00002c00', '\U00002c2e'),
- ('\U00002c30', '\U00002c5e'),
- ('\U00002c60', '\U00002ce4'),
- ('\U00002ceb', '\U00002cee'),
- ('\U00002cf2', '\U00002cf3'),
- ('\U00002d00', '\U00002d25'),
- ('\U00002d27', '\U00002d27'),
- ('\U00002d2d', '\U00002d2d'),
- ('\U00002d30', '\U00002d67'),
- ('\U00002d6f', '\U00002d6f'),
- ('\U00002d80', '\U00002d96'),
- ('\U00002da0', '\U00002da6'),
- ('\U00002da8', '\U00002dae'),
- ('\U00002db0', '\U00002db6'),
- ('\U00002db8', '\U00002dbe'),
- ('\U00002dc0', '\U00002dc6'),
- ('\U00002dc8', '\U00002dce'),
- ('\U00002dd0', '\U00002dd6'),
- ('\U00002dd8', '\U00002dde'),
- ('\U00002e2f', '\U00002e2f'),
- ('\U00003005', '\U00003006'),
- ('\U00003031', '\U00003035'),
- ('\U0000303b', '\U0000303c'),
- ('\U00003041', '\U00003096'),
- ('\U0000309d', '\U0000309f'),
- ('\U000030a1', '\U000030fa'),
- ('\U000030fc', '\U000030ff'),
- ('\U00003105', '\U0000312d'),
- ('\U00003131', '\U0000318e'),
- ('\U000031a0', '\U000031ba'),
- ('\U000031f0', '\U000031ff'),
- ('\U00003400', '\U00003400'),
- ('\U00004db5', '\U00004db5'),
- ('\U00004e00', '\U00004e00'),
- ('\U00009fcc', '\U00009fcc'),
- ('\U0000a000', '\U0000a48c'),
- ('\U0000a4d0', '\U0000a4fd'),
- ('\U0000a500', '\U0000a60c'),
- ('\U0000a610', '\U0000a61f'),
- ('\U0000a62a', '\U0000a62b'),
- ('\U0000a640', '\U0000a66e'),
- ('\U0000a67f', '\U0000a697'),
- ('\U0000a6a0', '\U0000a6e5'),
- ('\U0000a717', '\U0000a71f'),
- ('\U0000a722', '\U0000a788'),
- ('\U0000a78b', '\U0000a78e'),
- ('\U0000a790', '\U0000a793'),
- ('\U0000a7a0', '\U0000a7aa'),
- ('\U0000a7f8', '\U0000a801'),
- ('\U0000a803', '\U0000a805'),
- ('\U0000a807', '\U0000a80a'),
- ('\U0000a80c', '\U0000a822'),
- ('\U0000a840', '\U0000a873'),
- ('\U0000a882', '\U0000a8b3'),
- ('\U0000a8f2', '\U0000a8f7'),
- ('\U0000a8fb', '\U0000a8fb'),
- ('\U0000a90a', '\U0000a925'),
- ('\U0000a930', '\U0000a946'),
- ('\U0000a960', '\U0000a97c'),
- ('\U0000a984', '\U0000a9b2'),
- ('\U0000a9cf', '\U0000a9cf'),
- ('\U0000aa00', '\U0000aa28'),
- ('\U0000aa40', '\U0000aa42'),
- ('\U0000aa44', '\U0000aa4b'),
- ('\U0000aa60', '\U0000aa76'),
- ('\U0000aa7a', '\U0000aa7a'),
- ('\U0000aa80', '\U0000aaaf'),
- ('\U0000aab1', '\U0000aab1'),
- ('\U0000aab5', '\U0000aab6'),
- ('\U0000aab9', '\U0000aabd'),
- ('\U0000aac0', '\U0000aac0'),
- ('\U0000aac2', '\U0000aac2'),
- ('\U0000aadb', '\U0000aadd'),
- ('\U0000aae0', '\U0000aaea'),
- ('\U0000aaf2', '\U0000aaf4'),
- ('\U0000ab01', '\U0000ab06'),
- ('\U0000ab09', '\U0000ab0e'),
- ('\U0000ab11', '\U0000ab16'),
- ('\U0000ab20', '\U0000ab26'),
- ('\U0000ab28', '\U0000ab2e'),
- ('\U0000abc0', '\U0000abe2'),
- ('\U0000ac00', '\U0000ac00'),
- ('\U0000d7a3', '\U0000d7a3'),
- ('\U0000d7b0', '\U0000d7c6'),
- ('\U0000d7cb', '\U0000d7fb'),
- ('\U0000f900', '\U0000fa6d'),
- ('\U0000fa70', '\U0000fad9'),
- ('\U0000fb00', '\U0000fb06'),
- ('\U0000fb13', '\U0000fb17'),
- ('\U0000fb1d', '\U0000fb1d'),
- ('\U0000fb1f', '\U0000fb28'),
- ('\U0000fb2a', '\U0000fb36'),
- ('\U0000fb38', '\U0000fb3c'),
- ('\U0000fb3e', '\U0000fb3e'),
- ('\U0000fb40', '\U0000fb41'),
- ('\U0000fb43', '\U0000fb44'),
- ('\U0000fb46', '\U0000fbb1'),
- ('\U0000fbd3', '\U0000fd3d'),
- ('\U0000fd50', '\U0000fd8f'),
- ('\U0000fd92', '\U0000fdc7'),
- ('\U0000fdf0', '\U0000fdfb'),
- ('\U0000fe70', '\U0000fe74'),
- ('\U0000fe76', '\U0000fefc'),
- ('\U0000ff21', '\U0000ff3a'),
- ('\U0000ff41', '\U0000ff5a'),
- ('\U0000ff66', '\U0000ffbe'),
- ('\U0000ffc2', '\U0000ffc7'),
- ('\U0000ffca', '\U0000ffcf'),
- ('\U0000ffd2', '\U0000ffd7'),
- ('\U0000ffda', '\U0000ffdc'),
- ('\U00010000', '\U0001000b'),
- ('\U0001000d', '\U00010026'),
- ('\U00010028', '\U0001003a'),
- ('\U0001003c', '\U0001003d'),
- ('\U0001003f', '\U0001004d'),
- ('\U00010050', '\U0001005d'),
- ('\U00010080', '\U000100fa'),
- ('\U00010280', '\U0001029c'),
- ('\U000102a0', '\U000102d0'),
- ('\U00010300', '\U0001031e'),
- ('\U00010330', '\U00010340'),
- ('\U00010342', '\U00010349'),
- ('\U00010380', '\U0001039d'),
- ('\U000103a0', '\U000103c3'),
- ('\U000103c8', '\U000103cf'),
- ('\U00010400', '\U0001049d'),
- ('\U00010800', '\U00010805'),
- ('\U00010808', '\U00010808'),
- ('\U0001080a', '\U00010835'),
- ('\U00010837', '\U00010838'),
- ('\U0001083c', '\U0001083c'),
- ('\U0001083f', '\U00010855'),
- ('\U00010900', '\U00010915'),
- ('\U00010920', '\U00010939'),
- ('\U00010980', '\U000109b7'),
- ('\U000109be', '\U000109bf'),
- ('\U00010a00', '\U00010a00'),
- ('\U00010a10', '\U00010a13'),
- ('\U00010a15', '\U00010a17'),
- ('\U00010a19', '\U00010a33'),
- ('\U00010a60', '\U00010a7c'),
- ('\U00010b00', '\U00010b35'),
- ('\U00010b40', '\U00010b55'),
- ('\U00010b60', '\U00010b72'),
- ('\U00010c00', '\U00010c48'),
- ('\U00011003', '\U00011037'),
- ('\U00011083', '\U000110af'),
- ('\U000110d0', '\U000110e8'),
- ('\U00011103', '\U00011126'),
- ('\U00011183', '\U000111b2'),
- ('\U000111c1', '\U000111c4'),
- ('\U00011680', '\U000116aa'),
- ('\U00012000', '\U0001236e'),
- ('\U00013000', '\U0001342e'),
- ('\U00016800', '\U00016a38'),
- ('\U00016f00', '\U00016f44'),
- ('\U00016f50', '\U00016f50'),
- ('\U00016f93', '\U00016f9f'),
- ('\U0001b000', '\U0001b001'),
- ('\U0001d400', '\U0001d454'),
- ('\U0001d456', '\U0001d49c'),
- ('\U0001d49e', '\U0001d49f'),
- ('\U0001d4a2', '\U0001d4a2'),
- ('\U0001d4a5', '\U0001d4a6'),
- ('\U0001d4a9', '\U0001d4ac'),
- ('\U0001d4ae', '\U0001d4b9'),
- ('\U0001d4bb', '\U0001d4bb'),
- ('\U0001d4bd', '\U0001d4c3'),
- ('\U0001d4c5', '\U0001d505'),
- ('\U0001d507', '\U0001d50a'),
- ('\U0001d50d', '\U0001d514'),
- ('\U0001d516', '\U0001d51c'),
- ('\U0001d51e', '\U0001d539'),
- ('\U0001d53b', '\U0001d53e'),
- ('\U0001d540', '\U0001d544'),
- ('\U0001d546', '\U0001d546'),
- ('\U0001d54a', '\U0001d550'),
- ('\U0001d552', '\U0001d6a5'),
- ('\U0001d6a8', '\U0001d6c0'),
- ('\U0001d6c2', '\U0001d6da'),
- ('\U0001d6dc', '\U0001d6fa'),
- ('\U0001d6fc', '\U0001d714'),
- ('\U0001d716', '\U0001d734'),
- ('\U0001d736', '\U0001d74e'),
- ('\U0001d750', '\U0001d76e'),
- ('\U0001d770', '\U0001d788'),
- ('\U0001d78a', '\U0001d7a8'),
- ('\U0001d7aa', '\U0001d7c2'),
- ('\U0001d7c4', '\U0001d7cb'),
- ('\U0001ee00', '\U0001ee03'),
- ('\U0001ee05', '\U0001ee1f'),
- ('\U0001ee21', '\U0001ee22'),
- ('\U0001ee24', '\U0001ee24'),
- ('\U0001ee27', '\U0001ee27'),
- ('\U0001ee29', '\U0001ee32'),
- ('\U0001ee34', '\U0001ee37'),
- ('\U0001ee39', '\U0001ee39'),
- ('\U0001ee3b', '\U0001ee3b'),
- ('\U0001ee42', '\U0001ee42'),
- ('\U0001ee47', '\U0001ee47'),
- ('\U0001ee49', '\U0001ee49'),
- ('\U0001ee4b', '\U0001ee4b'),
- ('\U0001ee4d', '\U0001ee4f'),
- ('\U0001ee51', '\U0001ee52'),
- ('\U0001ee54', '\U0001ee54'),
- ('\U0001ee57', '\U0001ee57'),
- ('\U0001ee59', '\U0001ee59'),
- ('\U0001ee5b', '\U0001ee5b'),
- ('\U0001ee5d', '\U0001ee5d'),
- ('\U0001ee5f', '\U0001ee5f'),
- ('\U0001ee61', '\U0001ee62'),
- ('\U0001ee64', '\U0001ee64'),
- ('\U0001ee67', '\U0001ee6a'),
- ('\U0001ee6c', '\U0001ee72'),
- ('\U0001ee74', '\U0001ee77'),
- ('\U0001ee79', '\U0001ee7c'),
- ('\U0001ee7e', '\U0001ee7e'),
- ('\U0001ee80', '\U0001ee89'),
- ('\U0001ee8b', '\U0001ee9b'),
- ('\U0001eea1', '\U0001eea3'),
- ('\U0001eea5', '\U0001eea9'),
- ('\U0001eeab', '\U0001eebb'),
- ('\U00020000', '\U00020000'),
- ('\U0002a6d6', '\U0002a6d6'),
- ('\U0002a700', '\U0002a700'),
- ('\U0002b734', '\U0002b734'),
- ('\U0002b740', '\U0002b740'),
- ('\U0002b81d', '\U0002b81d'),
- ('\U0002f800', '\U0002fa1d')
- ]),
-("LC", &[
- ('\U00000041', '\U0000005a'),
- ('\U00000061', '\U0000007a'),
- ('\U000000b5', '\U000000b5'),
- ('\U000000c0', '\U000000d6'),
- ('\U000000d8', '\U000000f6'),
- ('\U000000f8', '\U000001ba'),
- ('\U000001bc', '\U000001bf'),
- ('\U000001c4', '\U00000293'),
- ('\U00000295', '\U000002af'),
- ('\U00000370', '\U00000373'),
- ('\U00000376', '\U00000377'),
- ('\U0000037b', '\U0000037d'),
- ('\U00000386', '\U00000386'),
- ('\U00000388', '\U0000038a'),
- ('\U0000038c', '\U0000038c'),
- ('\U0000038e', '\U000003a1'),
- ('\U000003a3', '\U000003f5'),
- ('\U000003f7', '\U00000481'),
- ('\U0000048a', '\U00000527'),
- ('\U00000531', '\U00000556'),
- ('\U00000561', '\U00000587'),
- ('\U000010a0', '\U000010c5'),
- ('\U000010c7', '\U000010c7'),
- ('\U000010cd', '\U000010cd'),
- ('\U00001d00', '\U00001d2b'),
- ('\U00001d6b', '\U00001d77'),
- ('\U00001d79', '\U00001d9a'),
- ('\U00001e00', '\U00001f15'),
- ('\U00001f18', '\U00001f1d'),
- ('\U00001f20', '\U00001f45'),
- ('\U00001f48', '\U00001f4d'),
- ('\U00001f50', '\U00001f57'),
- ('\U00001f59', '\U00001f59'),
- ('\U00001f5b', '\U00001f5b'),
- ('\U00001f5d', '\U00001f5d'),
- ('\U00001f5f', '\U00001f7d'),
- ('\U00001f80', '\U00001fb4'),
- ('\U00001fb6', '\U00001fbc'),
- ('\U00001fbe', '\U00001fbe'),
- ('\U00001fc2', '\U00001fc4'),
- ('\U00001fc6', '\U00001fcc'),
- ('\U00001fd0', '\U00001fd3'),
- ('\U00001fd6', '\U00001fdb'),
- ('\U00001fe0', '\U00001fec'),
- ('\U00001ff2', '\U00001ff4'),
- ('\U00001ff6', '\U00001ffc'),
- ('\U00002102', '\U00002102'),
- ('\U00002107', '\U00002107'),
- ('\U0000210a', '\U00002113'),
- ('\U00002115', '\U00002115'),
- ('\U00002119', '\U0000211d'),
- ('\U00002124', '\U00002124'),
- ('\U00002126', '\U00002126'),
- ('\U00002128', '\U00002128'),
- ('\U0000212a', '\U0000212d'),
- ('\U0000212f', '\U00002134'),
- ('\U00002139', '\U00002139'),
- ('\U0000213c', '\U0000213f'),
- ('\U00002145', '\U00002149'),
- ('\U0000214e', '\U0000214e'),
- ('\U00002183', '\U00002184'),
- ('\U00002c00', '\U00002c2e'),
- ('\U00002c30', '\U00002c5e'),
- ('\U00002c60', '\U00002c7b'),
- ('\U00002c7e', '\U00002ce4'),
- ('\U00002ceb', '\U00002cee'),
- ('\U00002cf2', '\U00002cf3'),
- ('\U00002d00', '\U00002d25'),
- ('\U00002d27', '\U00002d27'),
- ('\U00002d2d', '\U00002d2d'),
- ('\U0000a640', '\U0000a66d'),
- ('\U0000a680', '\U0000a697'),
- ('\U0000a722', '\U0000a76f'),
- ('\U0000a771', '\U0000a787'),
- ('\U0000a78b', '\U0000a78e'),
- ('\U0000a790', '\U0000a793'),
- ('\U0000a7a0', '\U0000a7aa'),
- ('\U0000a7fa', '\U0000a7fa'),
- ('\U0000fb00', '\U0000fb06'),
- ('\U0000fb13', '\U0000fb17'),
- ('\U0000ff21', '\U0000ff3a'),
- ('\U0000ff41', '\U0000ff5a'),
- ('\U00010400', '\U0001044f'),
- ('\U0001d400', '\U0001d454'),
- ('\U0001d456', '\U0001d49c'),
- ('\U0001d49e', '\U0001d49f'),
- ('\U0001d4a2', '\U0001d4a2'),
- ('\U0001d4a5', '\U0001d4a6'),
- ('\U0001d4a9', '\U0001d4ac'),
- ('\U0001d4ae', '\U0001d4b9'),
- ('\U0001d4bb', '\U0001d4bb'),
- ('\U0001d4bd', '\U0001d4c3'),
- ('\U0001d4c5', '\U0001d505'),
- ('\U0001d507', '\U0001d50a'),
- ('\U0001d50d', '\U0001d514'),
- ('\U0001d516', '\U0001d51c'),
- ('\U0001d51e', '\U0001d539'),
- ('\U0001d53b', '\U0001d53e'),
- ('\U0001d540', '\U0001d544'),
- ('\U0001d546', '\U0001d546'),
- ('\U0001d54a', '\U0001d550'),
- ('\U0001d552', '\U0001d6a5'),
- ('\U0001d6a8', '\U0001d6c0'),
- ('\U0001d6c2', '\U0001d6da'),
- ('\U0001d6dc', '\U0001d6fa'),
- ('\U0001d6fc', '\U0001d714'),
- ('\U0001d716', '\U0001d734'),
- ('\U0001d736', '\U0001d74e'),
- ('\U0001d750', '\U0001d76e'),
- ('\U0001d770', '\U0001d788'),
- ('\U0001d78a', '\U0001d7a8'),
- ('\U0001d7aa', '\U0001d7c2'),
- ('\U0001d7c4', '\U0001d7cb')
- ]),
-("Lao", &[
- ('\U00000e81', '\U00000e82'),
- ('\U00000e84', '\U00000e84'),
- ('\U00000e87', '\U00000e88'),
- ('\U00000e8a', '\U00000e8a'),
- ('\U00000e8d', '\U00000e8d'),
- ('\U00000e94', '\U00000e97'),
- ('\U00000e99', '\U00000e9f'),
- ('\U00000ea1', '\U00000ea3'),
- ('\U00000ea5', '\U00000ea5'),
- ('\U00000ea7', '\U00000ea7'),
- ('\U00000eaa', '\U00000eab'),
- ('\U00000ead', '\U00000eb9'),
- ('\U00000ebb', '\U00000ebd'),
- ('\U00000ec0', '\U00000ec4'),
- ('\U00000ec6', '\U00000ec6'),
- ('\U00000ec8', '\U00000ecd'),
- ('\U00000ed0', '\U00000ed9'),
- ('\U00000edc', '\U00000edf')
- ]),
-("Latin", &[
- ('\U00000041', '\U0000005a'),
- ('\U00000061', '\U0000007a'),
- ('\U000000aa', '\U000000aa'),
- ('\U000000ba', '\U000000ba'),
- ('\U000000c0', '\U000000d6'),
- ('\U000000d8', '\U000000f6'),
- ('\U000000f8', '\U000002b8'),
- ('\U000002e0', '\U000002e4'),
- ('\U00001d00', '\U00001d25'),
- ('\U00001d2c', '\U00001d5c'),
- ('\U00001d62', '\U00001d65'),
- ('\U00001d6b', '\U00001d77'),
- ('\U00001d79', '\U00001dbe'),
- ('\U00001e00', '\U00001eff'),
- ('\U00002071', '\U00002071'),
- ('\U0000207f', '\U0000207f'),
- ('\U00002090', '\U0000209c'),
- ('\U0000212a', '\U0000212b'),
- ('\U00002132', '\U00002132'),
- ('\U0000214e', '\U0000214e'),
- ('\U00002160', '\U00002188'),
- ('\U00002c60', '\U00002c7f'),
- ('\U0000a722', '\U0000a787'),
- ('\U0000a78b', '\U0000a78e'),
- ('\U0000a790', '\U0000a793'),
- ('\U0000a7a0', '\U0000a7aa'),
- ('\U0000a7f8', '\U0000a7ff'),
- ('\U0000fb00', '\U0000fb06'),
- ('\U0000ff21', '\U0000ff3a'),
- ('\U0000ff41', '\U0000ff5a')
- ]),
-("Lepcha", &[
- ('\U00001c00', '\U00001c37'),
- ('\U00001c3b', '\U00001c49'),
- ('\U00001c4d', '\U00001c4f')
- ]),
-("Limbu", &[
- ('\U00001900', '\U0000191c'),
- ('\U00001920', '\U0000192b'),
- ('\U00001930', '\U0000193b'),
- ('\U00001940', '\U00001940'),
- ('\U00001944', '\U0000194f')
- ]),
-("Linear_B", &[
- ('\U00010000', '\U0001000b'),
- ('\U0001000d', '\U00010026'),
- ('\U00010028', '\U0001003a'),
- ('\U0001003c', '\U0001003d'),
- ('\U0001003f', '\U0001004d'),
- ('\U00010050', '\U0001005d'),
- ('\U00010080', '\U000100fa')
- ]),
-("Lisu", &[
- ('\U0000a4d0', '\U0000a4ff')
- ]),
-("Ll", &[
- ('\U00000061', '\U0000007a'),
- ('\U000000b5', '\U000000b5'),
- ('\U000000df', '\U000000f6'),
- ('\U000000f8', '\U000000ff'),
- ('\U00000101', '\U00000101'),
- ('\U00000103', '\U00000103'),
- ('\U00000105', '\U00000105'),
- ('\U00000107', '\U00000107'),
- ('\U00000109', '\U00000109'),
- ('\U0000010b', '\U0000010b'),
- ('\U0000010d', '\U0000010d'),
- ('\U0000010f', '\U0000010f'),
- ('\U00000111', '\U00000111'),
- ('\U00000113', '\U00000113'),
- ('\U00000115', '\U00000115'),
- ('\U00000117', '\U00000117'),
- ('\U00000119', '\U00000119'),
- ('\U0000011b', '\U0000011b'),
- ('\U0000011d', '\U0000011d'),
- ('\U0000011f', '\U0000011f'),
- ('\U00000121', '\U00000121'),
- ('\U00000123', '\U00000123'),
- ('\U00000125', '\U00000125'),
- ('\U00000127', '\U00000127'),
- ('\U00000129', '\U00000129'),
- ('\U0000012b', '\U0000012b'),
- ('\U0000012d', '\U0000012d'),
- ('\U0000012f', '\U0000012f'),
- ('\U00000131', '\U00000131'),
- ('\U00000133', '\U00000133'),
- ('\U00000135', '\U00000135'),
- ('\U00000137', '\U00000138'),
- ('\U0000013a', '\U0000013a'),
- ('\U0000013c', '\U0000013c'),
- ('\U0000013e', '\U0000013e'),
- ('\U00000140', '\U00000140'),
- ('\U00000142', '\U00000142'),
- ('\U00000144', '\U00000144'),
- ('\U00000146', '\U00000146'),
- ('\U00000148', '\U00000149'),
- ('\U0000014b', '\U0000014b'),
- ('\U0000014d', '\U0000014d'),
- ('\U0000014f', '\U0000014f'),
- ('\U00000151', '\U00000151'),
- ('\U00000153', '\U00000153'),
- ('\U00000155', '\U00000155'),
- ('\U00000157', '\U00000157'),
- ('\U00000159', '\U00000159'),
- ('\U0000015b', '\U0000015b'),
- ('\U0000015d', '\U0000015d'),
- ('\U0000015f', '\U0000015f'),
- ('\U00000161', '\U00000161'),
- ('\U00000163', '\U00000163'),
- ('\U00000165', '\U00000165'),
- ('\U00000167', '\U00000167'),
- ('\U00000169', '\U00000169'),
- ('\U0000016b', '\U0000016b'),
- ('\U0000016d', '\U0000016d'),
- ('\U0000016f', '\U0000016f'),
- ('\U00000171', '\U00000171'),
- ('\U00000173', '\U00000173'),
- ('\U00000175', '\U00000175'),
- ('\U00000177', '\U00000177'),
- ('\U0000017a', '\U0000017a'),
- ('\U0000017c', '\U0000017c'),
- ('\U0000017e', '\U00000180'),
- ('\U00000183', '\U00000183'),
- ('\U00000185', '\U00000185'),
- ('\U00000188', '\U00000188'),
- ('\U0000018c', '\U0000018d'),
- ('\U00000192', '\U00000192'),
- ('\U00000195', '\U00000195'),
- ('\U00000199', '\U0000019b'),
- ('\U0000019e', '\U0000019e'),
- ('\U000001a1', '\U000001a1'),
- ('\U000001a3', '\U000001a3'),
- ('\U000001a5', '\U000001a5'),
- ('\U000001a8', '\U000001a8'),
- ('\U000001aa', '\U000001ab'),
- ('\U000001ad', '\U000001ad'),
- ('\U000001b0', '\U000001b0'),
- ('\U000001b4', '\U000001b4'),
- ('\U000001b6', '\U000001b6'),
- ('\U000001b9', '\U000001ba'),
- ('\U000001bd', '\U000001bf'),
- ('\U000001c6', '\U000001c6'),
- ('\U000001c9', '\U000001c9'),
- ('\U000001cc', '\U000001cc'),
- ('\U000001ce', '\U000001ce'),
- ('\U000001d0', '\U000001d0'),
- ('\U000001d2', '\U000001d2'),
- ('\U000001d4', '\U000001d4'),
- ('\U000001d6', '\U000001d6'),
- ('\U000001d8', '\U000001d8'),
- ('\U000001da', '\U000001da'),
- ('\U000001dc', '\U000001dd'),
- ('\U000001df', '\U000001df'),
- ('\U000001e1', '\U000001e1'),
- ('\U000001e3', '\U000001e3'),
- ('\U000001e5', '\U000001e5'),
- ('\U000001e7', '\U000001e7'),
- ('\U000001e9', '\U000001e9'),
- ('\U000001eb', '\U000001eb'),
- ('\U000001ed', '\U000001ed'),
- ('\U000001ef', '\U000001f0'),
- ('\U000001f3', '\U000001f3'),
- ('\U000001f5', '\U000001f5'),
- ('\U000001f9', '\U000001f9'),
- ('\U000001fb', '\U000001fb'),
- ('\U000001fd', '\U000001fd'),
- ('\U000001ff', '\U000001ff'),
- ('\U00000201', '\U00000201'),
- ('\U00000203', '\U00000203'),
- ('\U00000205', '\U00000205'),
- ('\U00000207', '\U00000207'),
- ('\U00000209', '\U00000209'),
- ('\U0000020b', '\U0000020b'),
- ('\U0000020d', '\U0000020d'),
- ('\U0000020f', '\U0000020f'),
- ('\U00000211', '\U00000211'),
- ('\U00000213', '\U00000213'),
- ('\U00000215', '\U00000215'),
- ('\U00000217', '\U00000217'),
- ('\U00000219', '\U00000219'),
- ('\U0000021b', '\U0000021b'),
- ('\U0000021d', '\U0000021d'),
- ('\U0000021f', '\U0000021f'),
- ('\U00000221', '\U00000221'),
- ('\U00000223', '\U00000223'),
- ('\U00000225', '\U00000225'),
- ('\U00000227', '\U00000227'),
- ('\U00000229', '\U00000229'),
- ('\U0000022b', '\U0000022b'),
- ('\U0000022d', '\U0000022d'),
- ('\U0000022f', '\U0000022f'),
- ('\U00000231', '\U00000231'),
- ('\U00000233', '\U00000239'),
- ('\U0000023c', '\U0000023c'),
- ('\U0000023f', '\U00000240'),
- ('\U00000242', '\U00000242'),
- ('\U00000247', '\U00000247'),
- ('\U00000249', '\U00000249'),
- ('\U0000024b', '\U0000024b'),
- ('\U0000024d', '\U0000024d'),
- ('\U0000024f', '\U00000293'),
- ('\U00000295', '\U000002af'),
- ('\U00000371', '\U00000371'),
- ('\U00000373', '\U00000373'),
- ('\U00000377', '\U00000377'),
- ('\U0000037b', '\U0000037d'),
- ('\U00000390', '\U00000390'),
- ('\U000003ac', '\U000003ce'),
- ('\U000003d0', '\U000003d1'),
- ('\U000003d5', '\U000003d7'),
- ('\U000003d9', '\U000003d9'),
- ('\U000003db', '\U000003db'),
- ('\U000003dd', '\U000003dd'),
- ('\U000003df', '\U000003df'),
- ('\U000003e1', '\U000003e1'),
- ('\U000003e3', '\U000003e3'),
- ('\U000003e5', '\U000003e5'),
- ('\U000003e7', '\U000003e7'),
- ('\U000003e9', '\U000003e9'),
- ('\U000003eb', '\U000003eb'),
- ('\U000003ed', '\U000003ed'),
- ('\U000003ef', '\U000003f3'),
- ('\U000003f5', '\U000003f5'),
- ('\U000003f8', '\U000003f8'),
- ('\U000003fb', '\U000003fc'),
- ('\U00000430', '\U0000045f'),
- ('\U00000461', '\U00000461'),
- ('\U00000463', '\U00000463'),
- ('\U00000465', '\U00000465'),
- ('\U00000467', '\U00000467'),
- ('\U00000469', '\U00000469'),
- ('\U0000046b', '\U0000046b'),
- ('\U0000046d', '\U0000046d'),
- ('\U0000046f', '\U0000046f'),
- ('\U00000471', '\U00000471'),
- ('\U00000473', '\U00000473'),
- ('\U00000475', '\U00000475'),
- ('\U00000477', '\U00000477'),
- ('\U00000479', '\U00000479'),
- ('\U0000047b', '\U0000047b'),
- ('\U0000047d', '\U0000047d'),
- ('\U0000047f', '\U0000047f'),
- ('\U00000481', '\U00000481'),
- ('\U0000048b', '\U0000048b'),
- ('\U0000048d', '\U0000048d'),
- ('\U0000048f', '\U0000048f'),
- ('\U00000491', '\U00000491'),
- ('\U00000493', '\U00000493'),
- ('\U00000495', '\U00000495'),
- ('\U00000497', '\U00000497'),
- ('\U00000499', '\U00000499'),
- ('\U0000049b', '\U0000049b'),
- ('\U0000049d', '\U0000049d'),
- ('\U0000049f', '\U0000049f'),
- ('\U000004a1', '\U000004a1'),
- ('\U000004a3', '\U000004a3'),
- ('\U000004a5', '\U000004a5'),
- ('\U000004a7', '\U000004a7'),
- ('\U000004a9', '\U000004a9'),
- ('\U000004ab', '\U000004ab'),
- ('\U000004ad', '\U000004ad'),
- ('\U000004af', '\U000004af'),
- ('\U000004b1', '\U000004b1'),
- ('\U000004b3', '\U000004b3'),
- ('\U000004b5', '\U000004b5'),
- ('\U000004b7', '\U000004b7'),
- ('\U000004b9', '\U000004b9'),
- ('\U000004bb', '\U000004bb'),
- ('\U000004bd', '\U000004bd'),
- ('\U000004bf', '\U000004bf'),
- ('\U000004c2', '\U000004c2'),
- ('\U000004c4', '\U000004c4'),
- ('\U000004c6', '\U000004c6'),
- ('\U000004c8', '\U000004c8'),
- ('\U000004ca', '\U000004ca'),
- ('\U000004cc', '\U000004cc'),
- ('\U000004ce', '\U000004cf'),
- ('\U000004d1', '\U000004d1'),
- ('\U000004d3', '\U000004d3'),
- ('\U000004d5', '\U000004d5'),
- ('\U000004d7', '\U000004d7'),
- ('\U000004d9', '\U000004d9'),
- ('\U000004db', '\U000004db'),
- ('\U000004dd', '\U000004dd'),
- ('\U000004df', '\U000004df'),
- ('\U000004e1', '\U000004e1'),
- ('\U000004e3', '\U000004e3'),
- ('\U000004e5', '\U000004e5'),
- ('\U000004e7', '\U000004e7'),
- ('\U000004e9', '\U000004e9'),
- ('\U000004eb', '\U000004eb'),
- ('\U000004ed', '\U000004ed'),
- ('\U000004ef', '\U000004ef'),
- ('\U000004f1', '\U000004f1'),
- ('\U000004f3', '\U000004f3'),
- ('\U000004f5', '\U000004f5'),
- ('\U000004f7', '\U000004f7'),
- ('\U000004f9', '\U000004f9'),
- ('\U000004fb', '\U000004fb'),
- ('\U000004fd', '\U000004fd'),
- ('\U000004ff', '\U000004ff'),
- ('\U00000501', '\U00000501'),
- ('\U00000503', '\U00000503'),
- ('\U00000505', '\U00000505'),
- ('\U00000507', '\U00000507'),
- ('\U00000509', '\U00000509'),
- ('\U0000050b', '\U0000050b'),
- ('\U0000050d', '\U0000050d'),
- ('\U0000050f', '\U0000050f'),
- ('\U00000511', '\U00000511'),
- ('\U00000513', '\U00000513'),
- ('\U00000515', '\U00000515'),
- ('\U00000517', '\U00000517'),
- ('\U00000519', '\U00000519'),
- ('\U0000051b', '\U0000051b'),
- ('\U0000051d', '\U0000051d'),
- ('\U0000051f', '\U0000051f'),
- ('\U00000521', '\U00000521'),
- ('\U00000523', '\U00000523'),
- ('\U00000525', '\U00000525'),
- ('\U00000527', '\U00000527'),
- ('\U00000561', '\U00000587'),
- ('\U00001d00', '\U00001d2b'),
- ('\U00001d6b', '\U00001d77'),
- ('\U00001d79', '\U00001d9a'),
- ('\U00001e01', '\U00001e01'),
- ('\U00001e03', '\U00001e03'),
- ('\U00001e05', '\U00001e05'),
- ('\U00001e07', '\U00001e07'),
- ('\U00001e09', '\U00001e09'),
- ('\U00001e0b', '\U00001e0b'),
- ('\U00001e0d', '\U00001e0d'),
- ('\U00001e0f', '\U00001e0f'),
- ('\U00001e11', '\U00001e11'),
- ('\U00001e13', '\U00001e13'),
- ('\U00001e15', '\U00001e15'),
- ('\U00001e17', '\U00001e17'),
- ('\U00001e19', '\U00001e19'),
- ('\U00001e1b', '\U00001e1b'),
- ('\U00001e1d', '\U00001e1d'),
- ('\U00001e1f', '\U00001e1f'),
- ('\U00001e21', '\U00001e21'),
- ('\U00001e23', '\U00001e23'),
- ('\U00001e25', '\U00001e25'),
- ('\U00001e27', '\U00001e27'),
- ('\U00001e29', '\U00001e29'),
- ('\U00001e2b', '\U00001e2b'),
- ('\U00001e2d', '\U00001e2d'),
- ('\U00001e2f', '\U00001e2f'),
- ('\U00001e31', '\U00001e31'),
- ('\U00001e33', '\U00001e33'),
- ('\U00001e35', '\U00001e35'),
- ('\U00001e37', '\U00001e37'),
- ('\U00001e39', '\U00001e39'),
- ('\U00001e3b', '\U00001e3b'),
- ('\U00001e3d', '\U00001e3d'),
- ('\U00001e3f', '\U00001e3f'),
- ('\U00001e41', '\U00001e41'),
- ('\U00001e43', '\U00001e43'),
- ('\U00001e45', '\U00001e45'),
- ('\U00001e47', '\U00001e47'),
- ('\U00001e49', '\U00001e49'),
- ('\U00001e4b', '\U00001e4b'),
- ('\U00001e4d', '\U00001e4d'),
- ('\U00001e4f', '\U00001e4f'),
- ('\U00001e51', '\U00001e51'),
- ('\U00001e53', '\U00001e53'),
- ('\U00001e55', '\U00001e55'),
- ('\U00001e57', '\U00001e57'),
- ('\U00001e59', '\U00001e59'),
- ('\U00001e5b', '\U00001e5b'),
- ('\U00001e5d', '\U00001e5d'),
- ('\U00001e5f', '\U00001e5f'),
- ('\U00001e61', '\U00001e61'),
- ('\U00001e63', '\U00001e63'),
- ('\U00001e65', '\U00001e65'),
- ('\U00001e67', '\U00001e67'),
- ('\U00001e69', '\U00001e69'),
- ('\U00001e6b', '\U00001e6b'),
- ('\U00001e6d', '\U00001e6d'),
- ('\U00001e6f', '\U00001e6f'),
- ('\U00001e71', '\U00001e71'),
- ('\U00001e73', '\U00001e73'),
- ('\U00001e75', '\U00001e75'),
- ('\U00001e77', '\U00001e77'),
- ('\U00001e79', '\U00001e79'),
- ('\U00001e7b', '\U00001e7b'),
- ('\U00001e7d', '\U00001e7d'),
- ('\U00001e7f', '\U00001e7f'),
- ('\U00001e81', '\U00001e81'),
- ('\U00001e83', '\U00001e83'),
- ('\U00001e85', '\U00001e85'),
- ('\U00001e87', '\U00001e87'),
- ('\U00001e89', '\U00001e89'),
- ('\U00001e8b', '\U00001e8b'),
- ('\U00001e8d', '\U00001e8d'),
- ('\U00001e8f', '\U00001e8f'),
- ('\U00001e91', '\U00001e91'),
- ('\U00001e93', '\U00001e93'),
- ('\U00001e95', '\U00001e9d'),
- ('\U00001e9f', '\U00001e9f'),
- ('\U00001ea1', '\U00001ea1'),
- ('\U00001ea3', '\U00001ea3'),
- ('\U00001ea5', '\U00001ea5'),
- ('\U00001ea7', '\U00001ea7'),
- ('\U00001ea9', '\U00001ea9'),
- ('\U00001eab', '\U00001eab'),
- ('\U00001ead', '\U00001ead'),
- ('\U00001eaf', '\U00001eaf'),
- ('\U00001eb1', '\U00001eb1'),
- ('\U00001eb3', '\U00001eb3'),
- ('\U00001eb5', '\U00001eb5'),
- ('\U00001eb7', '\U00001eb7'),
- ('\U00001eb9', '\U00001eb9'),
- ('\U00001ebb', '\U00001ebb'),
- ('\U00001ebd', '\U00001ebd'),
- ('\U00001ebf', '\U00001ebf'),
- ('\U00001ec1', '\U00001ec1'),
- ('\U00001ec3', '\U00001ec3'),
- ('\U00001ec5', '\U00001ec5'),
- ('\U00001ec7', '\U00001ec7'),
- ('\U00001ec9', '\U00001ec9'),
- ('\U00001ecb', '\U00001ecb'),
- ('\U00001ecd', '\U00001ecd'),
- ('\U00001ecf', '\U00001ecf'),
- ('\U00001ed1', '\U00001ed1'),
- ('\U00001ed3', '\U00001ed3'),
- ('\U00001ed5', '\U00001ed5'),
- ('\U00001ed7', '\U00001ed7'),
- ('\U00001ed9', '\U00001ed9'),
- ('\U00001edb', '\U00001edb'),
- ('\U00001edd', '\U00001edd'),
- ('\U00001edf', '\U00001edf'),
- ('\U00001ee1', '\U00001ee1'),
- ('\U00001ee3', '\U00001ee3'),
- ('\U00001ee5', '\U00001ee5'),
- ('\U00001ee7', '\U00001ee7'),
- ('\U00001ee9', '\U00001ee9'),
- ('\U00001eeb', '\U00001eeb'),
- ('\U00001eed', '\U00001eed'),
- ('\U00001eef', '\U00001eef'),
- ('\U00001ef1', '\U00001ef1'),
- ('\U00001ef3', '\U00001ef3'),
- ('\U00001ef5', '\U00001ef5'),
- ('\U00001ef7', '\U00001ef7'),
- ('\U00001ef9', '\U00001ef9'),
- ('\U00001efb', '\U00001efb'),
- ('\U00001efd', '\U00001efd'),
- ('\U00001eff', '\U00001f07'),
- ('\U00001f10', '\U00001f15'),
- ('\U00001f20', '\U00001f27'),
- ('\U00001f30', '\U00001f37'),
- ('\U00001f40', '\U00001f45'),
- ('\U00001f50', '\U00001f57'),
- ('\U00001f60', '\U00001f67'),
- ('\U00001f70', '\U00001f7d'),
- ('\U00001f80', '\U00001f87'),
- ('\U00001f90', '\U00001f97'),
- ('\U00001fa0', '\U00001fa7'),
- ('\U00001fb0', '\U00001fb4'),
- ('\U00001fb6', '\U00001fb7'),
- ('\U00001fbe', '\U00001fbe'),
- ('\U00001fc2', '\U00001fc4'),
- ('\U00001fc6', '\U00001fc7'),
- ('\U00001fd0', '\U00001fd3'),
- ('\U00001fd6', '\U00001fd7'),
- ('\U00001fe0', '\U00001fe7'),
- ('\U00001ff2', '\U00001ff4'),
- ('\U00001ff6', '\U00001ff7'),
- ('\U0000210a', '\U0000210a'),
- ('\U0000210e', '\U0000210f'),
- ('\U00002113', '\U00002113'),
- ('\U0000212f', '\U0000212f'),
- ('\U00002134', '\U00002134'),
- ('\U00002139', '\U00002139'),
- ('\U0000213c', '\U0000213d'),
- ('\U00002146', '\U00002149'),
- ('\U0000214e', '\U0000214e'),
- ('\U00002184', '\U00002184'),
- ('\U00002c30', '\U00002c5e'),
- ('\U00002c61', '\U00002c61'),
- ('\U00002c65', '\U00002c66'),
- ('\U00002c68', '\U00002c68'),
- ('\U00002c6a', '\U00002c6a'),
- ('\U00002c6c', '\U00002c6c'),
- ('\U00002c71', '\U00002c71'),
- ('\U00002c73', '\U00002c74'),
- ('\U00002c76', '\U00002c7b'),
- ('\U00002c81', '\U00002c81'),
- ('\U00002c83', '\U00002c83'),
- ('\U00002c85', '\U00002c85'),
- ('\U00002c87', '\U00002c87'),
- ('\U00002c89', '\U00002c89'),
- ('\U00002c8b', '\U00002c8b'),
- ('\U00002c8d', '\U00002c8d'),
- ('\U00002c8f', '\U00002c8f'),
- ('\U00002c91', '\U00002c91'),
- ('\U00002c93', '\U00002c93'),
- ('\U00002c95', '\U00002c95'),
- ('\U00002c97', '\U00002c97'),
- ('\U00002c99', '\U00002c99'),
- ('\U00002c9b', '\U00002c9b'),
- ('\U00002c9d', '\U00002c9d'),
- ('\U00002c9f', '\U00002c9f'),
- ('\U00002ca1', '\U00002ca1'),
- ('\U00002ca3', '\U00002ca3'),
- ('\U00002ca5', '\U00002ca5'),
- ('\U00002ca7', '\U00002ca7'),
- ('\U00002ca9', '\U00002ca9'),
- ('\U00002cab', '\U00002cab'),
- ('\U00002cad', '\U00002cad'),
- ('\U00002caf', '\U00002caf'),
- ('\U00002cb1', '\U00002cb1'),
- ('\U00002cb3', '\U00002cb3'),
- ('\U00002cb5', '\U00002cb5'),
- ('\U00002cb7', '\U00002cb7'),
- ('\U00002cb9', '\U00002cb9'),
- ('\U00002cbb', '\U00002cbb'),
- ('\U00002cbd', '\U00002cbd'),
- ('\U00002cbf', '\U00002cbf'),
- ('\U00002cc1', '\U00002cc1'),
- ('\U00002cc3', '\U00002cc3'),
- ('\U00002cc5', '\U00002cc5'),
- ('\U00002cc7', '\U00002cc7'),
- ('\U00002cc9', '\U00002cc9'),
- ('\U00002ccb', '\U00002ccb'),
- ('\U00002ccd', '\U00002ccd'),
- ('\U00002ccf', '\U00002ccf'),
- ('\U00002cd1', '\U00002cd1'),
- ('\U00002cd3', '\U00002cd3'),
- ('\U00002cd5', '\U00002cd5'),
- ('\U00002cd7', '\U00002cd7'),
- ('\U00002cd9', '\U00002cd9'),
- ('\U00002cdb', '\U00002cdb'),
- ('\U00002cdd', '\U00002cdd'),
- ('\U00002cdf', '\U00002cdf'),
- ('\U00002ce1', '\U00002ce1'),
- ('\U00002ce3', '\U00002ce4'),
- ('\U00002cec', '\U00002cec'),
- ('\U00002cee', '\U00002cee'),
- ('\U00002cf3', '\U00002cf3'),
- ('\U00002d00', '\U00002d25'),
- ('\U00002d27', '\U00002d27'),
- ('\U00002d2d', '\U00002d2d'),
- ('\U0000a641', '\U0000a641'),
- ('\U0000a643', '\U0000a643'),
- ('\U0000a645', '\U0000a645'),
- ('\U0000a647', '\U0000a647'),
- ('\U0000a649', '\U0000a649'),
- ('\U0000a64b', '\U0000a64b'),
- ('\U0000a64d', '\U0000a64d'),
- ('\U0000a64f', '\U0000a64f'),
- ('\U0000a651', '\U0000a651'),
- ('\U0000a653', '\U0000a653'),
- ('\U0000a655', '\U0000a655'),
- ('\U0000a657', '\U0000a657'),
- ('\U0000a659', '\U0000a659'),
- ('\U0000a65b', '\U0000a65b'),
- ('\U0000a65d', '\U0000a65d'),
- ('\U0000a65f', '\U0000a65f'),
- ('\U0000a661', '\U0000a661'),
- ('\U0000a663', '\U0000a663'),
- ('\U0000a665', '\U0000a665'),
- ('\U0000a667', '\U0000a667'),
- ('\U0000a669', '\U0000a669'),
- ('\U0000a66b', '\U0000a66b'),
- ('\U0000a66d', '\U0000a66d'),
- ('\U0000a681', '\U0000a681'),
- ('\U0000a683', '\U0000a683'),
- ('\U0000a685', '\U0000a685'),
- ('\U0000a687', '\U0000a687'),
- ('\U0000a689', '\U0000a689'),
- ('\U0000a68b', '\U0000a68b'),
- ('\U0000a68d', '\U0000a68d'),
- ('\U0000a68f', '\U0000a68f'),
- ('\U0000a691', '\U0000a691'),
- ('\U0000a693', '\U0000a693'),
- ('\U0000a695', '\U0000a695'),
- ('\U0000a697', '\U0000a697'),
- ('\U0000a723', '\U0000a723'),
- ('\U0000a725', '\U0000a725'),
- ('\U0000a727', '\U0000a727'),
- ('\U0000a729', '\U0000a729'),
- ('\U0000a72b', '\U0000a72b'),
- ('\U0000a72d', '\U0000a72d'),
- ('\U0000a72f', '\U0000a731'),
- ('\U0000a733', '\U0000a733'),
- ('\U0000a735', '\U0000a735'),
- ('\U0000a737', '\U0000a737'),
- ('\U0000a739', '\U0000a739'),
- ('\U0000a73b', '\U0000a73b'),
- ('\U0000a73d', '\U0000a73d'),
- ('\U0000a73f', '\U0000a73f'),
- ('\U0000a741', '\U0000a741'),
- ('\U0000a743', '\U0000a743'),
- ('\U0000a745', '\U0000a745'),
- ('\U0000a747', '\U0000a747'),
- ('\U0000a749', '\U0000a749'),
- ('\U0000a74b', '\U0000a74b'),
- ('\U0000a74d', '\U0000a74d'),
- ('\U0000a74f', '\U0000a74f'),
- ('\U0000a751', '\U0000a751'),
- ('\U0000a753', '\U0000a753'),
- ('\U0000a755', '\U0000a755'),
- ('\U0000a757', '\U0000a757'),
- ('\U0000a759', '\U0000a759'),
- ('\U0000a75b', '\U0000a75b'),
- ('\U0000a75d', '\U0000a75d'),
- ('\U0000a75f', '\U0000a75f'),
- ('\U0000a761', '\U0000a761'),
- ('\U0000a763', '\U0000a763'),
- ('\U0000a765', '\U0000a765'),
- ('\U0000a767', '\U0000a767'),
- ('\U0000a769', '\U0000a769'),
- ('\U0000a76b', '\U0000a76b'),
- ('\U0000a76d', '\U0000a76d'),
- ('\U0000a76f', '\U0000a76f'),
- ('\U0000a771', '\U0000a778'),
- ('\U0000a77a', '\U0000a77a'),
- ('\U0000a77c', '\U0000a77c'),
- ('\U0000a77f', '\U0000a77f'),
- ('\U0000a781', '\U0000a781'),
- ('\U0000a783', '\U0000a783'),
- ('\U0000a785', '\U0000a785'),
- ('\U0000a787', '\U0000a787'),
- ('\U0000a78c', '\U0000a78c'),
- ('\U0000a78e', '\U0000a78e'),
- ('\U0000a791', '\U0000a791'),
- ('\U0000a793', '\U0000a793'),
- ('\U0000a7a1', '\U0000a7a1'),
- ('\U0000a7a3', '\U0000a7a3'),
- ('\U0000a7a5', '\U0000a7a5'),
- ('\U0000a7a7', '\U0000a7a7'),
- ('\U0000a7a9', '\U0000a7a9'),
- ('\U0000a7fa', '\U0000a7fa'),
- ('\U0000fb00', '\U0000fb06'),
- ('\U0000fb13', '\U0000fb17'),
- ('\U0000ff41', '\U0000ff5a'),
- ('\U00010428', '\U0001044f'),
- ('\U0001d41a', '\U0001d433'),
- ('\U0001d44e', '\U0001d454'),
- ('\U0001d456', '\U0001d467'),
- ('\U0001d482', '\U0001d49b'),
- ('\U0001d4b6', '\U0001d4b9'),
- ('\U0001d4bb', '\U0001d4bb'),
- ('\U0001d4bd', '\U0001d4c3'),
- ('\U0001d4c5', '\U0001d4cf'),
- ('\U0001d4ea', '\U0001d503'),
- ('\U0001d51e', '\U0001d537'),
- ('\U0001d552', '\U0001d56b'),
- ('\U0001d586', '\U0001d59f'),
- ('\U0001d5ba', '\U0001d5d3'),
- ('\U0001d5ee', '\U0001d607'),
- ('\U0001d622', '\U0001d63b'),
- ('\U0001d656', '\U0001d66f'),
- ('\U0001d68a', '\U0001d6a5'),
- ('\U0001d6c2', '\U0001d6da'),
- ('\U0001d6dc', '\U0001d6e1'),
- ('\U0001d6fc', '\U0001d714'),
- ('\U0001d716', '\U0001d71b'),
- ('\U0001d736', '\U0001d74e'),
- ('\U0001d750', '\U0001d755'),
- ('\U0001d770', '\U0001d788'),
- ('\U0001d78a', '\U0001d78f'),
- ('\U0001d7aa', '\U0001d7c2'),
- ('\U0001d7c4', '\U0001d7c9'),
- ('\U0001d7cb', '\U0001d7cb')
- ]),
-("Lm", &[
- ('\U000002b0', '\U000002c1'),
- ('\U000002c6', '\U000002d1'),
- ('\U000002e0', '\U000002e4'),
- ('\U000002ec', '\U000002ec'),
- ('\U000002ee', '\U000002ee'),
- ('\U00000374', '\U00000374'),
- ('\U0000037a', '\U0000037a'),
- ('\U00000559', '\U00000559'),
- ('\U00000640', '\U00000640'),
- ('\U000006e5', '\U000006e6'),
- ('\U000007f4', '\U000007f5'),
- ('\U000007fa', '\U000007fa'),
- ('\U0000081a', '\U0000081a'),
- ('\U00000824', '\U00000824'),
- ('\U00000828', '\U00000828'),
- ('\U00000971', '\U00000971'),
- ('\U00000e46', '\U00000e46'),
- ('\U00000ec6', '\U00000ec6'),
- ('\U000010fc', '\U000010fc'),
- ('\U000017d7', '\U000017d7'),
- ('\U00001843', '\U00001843'),
- ('\U00001aa7', '\U00001aa7'),
- ('\U00001c78', '\U00001c7d'),
- ('\U00001d2c', '\U00001d6a'),
- ('\U00001d78', '\U00001d78'),
- ('\U00001d9b', '\U00001dbf'),
- ('\U00002071', '\U00002071'),
- ('\U0000207f', '\U0000207f'),
- ('\U00002090', '\U0000209c'),
- ('\U00002c7c', '\U00002c7d'),
- ('\U00002d6f', '\U00002d6f'),
- ('\U00002e2f', '\U00002e2f'),
- ('\U00003005', '\U00003005'),
- ('\U00003031', '\U00003035'),
- ('\U0000303b', '\U0000303b'),
- ('\U0000309d', '\U0000309e'),
- ('\U000030fc', '\U000030fe'),
- ('\U0000a015', '\U0000a015'),
- ('\U0000a4f8', '\U0000a4fd'),
- ('\U0000a60c', '\U0000a60c'),
- ('\U0000a67f', '\U0000a67f'),
- ('\U0000a717', '\U0000a71f'),
- ('\U0000a770', '\U0000a770'),
- ('\U0000a788', '\U0000a788'),
- ('\U0000a7f8', '\U0000a7f9'),
- ('\U0000a9cf', '\U0000a9cf'),
- ('\U0000aa70', '\U0000aa70'),
- ('\U0000aadd', '\U0000aadd'),
- ('\U0000aaf3', '\U0000aaf4'),
- ('\U0000ff70', '\U0000ff70'),
- ('\U0000ff9e', '\U0000ff9f'),
- ('\U00016f93', '\U00016f9f')
- ]),
-("Lo", &[
- ('\U000000aa', '\U000000aa'),
- ('\U000000ba', '\U000000ba'),
- ('\U000001bb', '\U000001bb'),
- ('\U000001c0', '\U000001c3'),
- ('\U00000294', '\U00000294'),
- ('\U000005d0', '\U000005ea'),
- ('\U000005f0', '\U000005f2'),
- ('\U00000620', '\U0000063f'),
- ('\U00000641', '\U0000064a'),
- ('\U0000066e', '\U0000066f'),
- ('\U00000671', '\U000006d3'),
- ('\U000006d5', '\U000006d5'),
- ('\U000006ee', '\U000006ef'),
- ('\U000006fa', '\U000006fc'),
- ('\U000006ff', '\U000006ff'),
- ('\U00000710', '\U00000710'),
- ('\U00000712', '\U0000072f'),
- ('\U0000074d', '\U000007a5'),
- ('\U000007b1', '\U000007b1'),
- ('\U000007ca', '\U000007ea'),
- ('\U00000800', '\U00000815'),
- ('\U00000840', '\U00000858'),
- ('\U000008a0', '\U000008a0'),
- ('\U000008a2', '\U000008ac'),
- ('\U00000904', '\U00000939'),
- ('\U0000093d', '\U0000093d'),
- ('\U00000950', '\U00000950'),
- ('\U00000958', '\U00000961'),
- ('\U00000972', '\U00000977'),
- ('\U00000979', '\U0000097f'),
- ('\U00000985', '\U0000098c'),
- ('\U0000098f', '\U00000990'),
- ('\U00000993', '\U000009a8'),
- ('\U000009aa', '\U000009b0'),
- ('\U000009b2', '\U000009b2'),
- ('\U000009b6', '\U000009b9'),
- ('\U000009bd', '\U000009bd'),
- ('\U000009ce', '\U000009ce'),
- ('\U000009dc', '\U000009dd'),
- ('\U000009df', '\U000009e1'),
- ('\U000009f0', '\U000009f1'),
- ('\U00000a05', '\U00000a0a'),
- ('\U00000a0f', '\U00000a10'),
- ('\U00000a13', '\U00000a28'),
- ('\U00000a2a', '\U00000a30'),
- ('\U00000a32', '\U00000a33'),
- ('\U00000a35', '\U00000a36'),
- ('\U00000a38', '\U00000a39'),
- ('\U00000a59', '\U00000a5c'),
- ('\U00000a5e', '\U00000a5e'),
- ('\U00000a72', '\U00000a74'),
- ('\U00000a85', '\U00000a8d'),
- ('\U00000a8f', '\U00000a91'),
- ('\U00000a93', '\U00000aa8'),
- ('\U00000aaa', '\U00000ab0'),
- ('\U00000ab2', '\U00000ab3'),
- ('\U00000ab5', '\U00000ab9'),
- ('\U00000abd', '\U00000abd'),
- ('\U00000ad0', '\U00000ad0'),
- ('\U00000ae0', '\U00000ae1'),
- ('\U00000b05', '\U00000b0c'),
- ('\U00000b0f', '\U00000b10'),
- ('\U00000b13', '\U00000b28'),
- ('\U00000b2a', '\U00000b30'),
- ('\U00000b32', '\U00000b33'),
- ('\U00000b35', '\U00000b39'),
- ('\U00000b3d', '\U00000b3d'),
- ('\U00000b5c', '\U00000b5d'),
- ('\U00000b5f', '\U00000b61'),
- ('\U00000b71', '\U00000b71'),
- ('\U00000b83', '\U00000b83'),
- ('\U00000b85', '\U00000b8a'),
- ('\U00000b8e', '\U00000b90'),
- ('\U00000b92', '\U00000b95'),
- ('\U00000b99', '\U00000b9a'),
- ('\U00000b9c', '\U00000b9c'),
- ('\U00000b9e', '\U00000b9f'),
- ('\U00000ba3', '\U00000ba4'),
- ('\U00000ba8', '\U00000baa'),
- ('\U00000bae', '\U00000bb9'),
- ('\U00000bd0', '\U00000bd0'),
- ('\U00000c05', '\U00000c0c'),
- ('\U00000c0e', '\U00000c10'),
- ('\U00000c12', '\U00000c28'),
- ('\U00000c2a', '\U00000c33'),
- ('\U00000c35', '\U00000c39'),
- ('\U00000c3d', '\U00000c3d'),
- ('\U00000c58', '\U00000c59'),
- ('\U00000c60', '\U00000c61'),
- ('\U00000c85', '\U00000c8c'),
- ('\U00000c8e', '\U00000c90'),
- ('\U00000c92', '\U00000ca8'),
- ('\U00000caa', '\U00000cb3'),
- ('\U00000cb5', '\U00000cb9'),
- ('\U00000cbd', '\U00000cbd'),
- ('\U00000cde', '\U00000cde'),
- ('\U00000ce0', '\U00000ce1'),
- ('\U00000cf1', '\U00000cf2'),
- ('\U00000d05', '\U00000d0c'),
- ('\U00000d0e', '\U00000d10'),
- ('\U00000d12', '\U00000d3a'),
- ('\U00000d3d', '\U00000d3d'),
- ('\U00000d4e', '\U00000d4e'),
- ('\U00000d60', '\U00000d61'),
- ('\U00000d7a', '\U00000d7f'),
- ('\U00000d85', '\U00000d96'),
- ('\U00000d9a', '\U00000db1'),
- ('\U00000db3', '\U00000dbb'),
- ('\U00000dbd', '\U00000dbd'),
- ('\U00000dc0', '\U00000dc6'),
- ('\U00000e01', '\U00000e30'),
- ('\U00000e32', '\U00000e33'),
- ('\U00000e40', '\U00000e45'),
- ('\U00000e81', '\U00000e82'),
- ('\U00000e84', '\U00000e84'),
- ('\U00000e87', '\U00000e88'),
- ('\U00000e8a', '\U00000e8a'),
- ('\U00000e8d', '\U00000e8d'),
- ('\U00000e94', '\U00000e97'),
- ('\U00000e99', '\U00000e9f'),
- ('\U00000ea1', '\U00000ea3'),
- ('\U00000ea5', '\U00000ea5'),
- ('\U00000ea7', '\U00000ea7'),
- ('\U00000eaa', '\U00000eab'),
- ('\U00000ead', '\U00000eb0'),
- ('\U00000eb2', '\U00000eb3'),
- ('\U00000ebd', '\U00000ebd'),
- ('\U00000ec0', '\U00000ec4'),
- ('\U00000edc', '\U00000edf'),
- ('\U00000f00', '\U00000f00'),
- ('\U00000f40', '\U00000f47'),
- ('\U00000f49', '\U00000f6c'),
- ('\U00000f88', '\U00000f8c'),
- ('\U00001000', '\U0000102a'),
- ('\U0000103f', '\U0000103f'),
- ('\U00001050', '\U00001055'),
- ('\U0000105a', '\U0000105d'),
- ('\U00001061', '\U00001061'),
- ('\U00001065', '\U00001066'),
- ('\U0000106e', '\U00001070'),
- ('\U00001075', '\U00001081'),
- ('\U0000108e', '\U0000108e'),
- ('\U000010d0', '\U000010fa'),
- ('\U000010fd', '\U00001248'),
- ('\U0000124a', '\U0000124d'),
- ('\U00001250', '\U00001256'),
- ('\U00001258', '\U00001258'),
- ('\U0000125a', '\U0000125d'),
- ('\U00001260', '\U00001288'),
- ('\U0000128a', '\U0000128d'),
- ('\U00001290', '\U000012b0'),
- ('\U000012b2', '\U000012b5'),
- ('\U000012b8', '\U000012be'),
- ('\U000012c0', '\U000012c0'),
- ('\U000012c2', '\U000012c5'),
- ('\U000012c8', '\U000012d6'),
- ('\U000012d8', '\U00001310'),
- ('\U00001312', '\U00001315'),
- ('\U00001318', '\U0000135a'),
- ('\U00001380', '\U0000138f'),
- ('\U000013a0', '\U000013f4'),
- ('\U00001401', '\U0000166c'),
- ('\U0000166f', '\U0000167f'),
- ('\U00001681', '\U0000169a'),
- ('\U000016a0', '\U000016ea'),
- ('\U00001700', '\U0000170c'),
- ('\U0000170e', '\U00001711'),
- ('\U00001720', '\U00001731'),
- ('\U00001740', '\U00001751'),
- ('\U00001760', '\U0000176c'),
- ('\U0000176e', '\U00001770'),
- ('\U00001780', '\U000017b3'),
- ('\U000017dc', '\U000017dc'),
- ('\U00001820', '\U00001842'),
- ('\U00001844', '\U00001877'),
- ('\U00001880', '\U000018a8'),
- ('\U000018aa', '\U000018aa'),
- ('\U000018b0', '\U000018f5'),
- ('\U00001900', '\U0000191c'),
- ('\U00001950', '\U0000196d'),
- ('\U00001970', '\U00001974'),
- ('\U00001980', '\U000019ab'),
- ('\U000019c1', '\U000019c7'),
- ('\U00001a00', '\U00001a16'),
- ('\U00001a20', '\U00001a54'),
- ('\U00001b05', '\U00001b33'),
- ('\U00001b45', '\U00001b4b'),
- ('\U00001b83', '\U00001ba0'),
- ('\U00001bae', '\U00001baf'),
- ('\U00001bba', '\U00001be5'),
- ('\U00001c00', '\U00001c23'),
- ('\U00001c4d', '\U00001c4f'),
- ('\U00001c5a', '\U00001c77'),
- ('\U00001ce9', '\U00001cec'),
- ('\U00001cee', '\U00001cf1'),
- ('\U00001cf5', '\U00001cf6'),
- ('\U00002135', '\U00002138'),
- ('\U00002d30', '\U00002d67'),
- ('\U00002d80', '\U00002d96'),
- ('\U00002da0', '\U00002da6'),
- ('\U00002da8', '\U00002dae'),
- ('\U00002db0', '\U00002db6'),
- ('\U00002db8', '\U00002dbe'),
- ('\U00002dc0', '\U00002dc6'),
- ('\U00002dc8', '\U00002dce'),
- ('\U00002dd0', '\U00002dd6'),
- ('\U00002dd8', '\U00002dde'),
- ('\U00003006', '\U00003006'),
- ('\U0000303c', '\U0000303c'),
- ('\U00003041', '\U00003096'),
- ('\U0000309f', '\U0000309f'),
- ('\U000030a1', '\U000030fa'),
- ('\U000030ff', '\U000030ff'),
- ('\U00003105', '\U0000312d'),
- ('\U00003131', '\U0000318e'),
- ('\U000031a0', '\U000031ba'),
- ('\U000031f0', '\U000031ff'),
- ('\U00003400', '\U00003400'),
- ('\U00004db5', '\U00004db5'),
- ('\U00004e00', '\U00004e00'),
- ('\U00009fcc', '\U00009fcc'),
- ('\U0000a000', '\U0000a014'),
- ('\U0000a016', '\U0000a48c'),
- ('\U0000a4d0', '\U0000a4f7'),
- ('\U0000a500', '\U0000a60b'),
- ('\U0000a610', '\U0000a61f'),
- ('\U0000a62a', '\U0000a62b'),
- ('\U0000a66e', '\U0000a66e'),
- ('\U0000a6a0', '\U0000a6e5'),
- ('\U0000a7fb', '\U0000a801'),
- ('\U0000a803', '\U0000a805'),
- ('\U0000a807', '\U0000a80a'),
- ('\U0000a80c', '\U0000a822'),
- ('\U0000a840', '\U0000a873'),
- ('\U0000a882', '\U0000a8b3'),
- ('\U0000a8f2', '\U0000a8f7'),
- ('\U0000a8fb', '\U0000a8fb'),
- ('\U0000a90a', '\U0000a925'),
- ('\U0000a930', '\U0000a946'),
- ('\U0000a960', '\U0000a97c'),
- ('\U0000a984', '\U0000a9b2'),
- ('\U0000aa00', '\U0000aa28'),
- ('\U0000aa40', '\U0000aa42'),
- ('\U0000aa44', '\U0000aa4b'),
- ('\U0000aa60', '\U0000aa6f'),
- ('\U0000aa71', '\U0000aa76'),
- ('\U0000aa7a', '\U0000aa7a'),
- ('\U0000aa80', '\U0000aaaf'),
- ('\U0000aab1', '\U0000aab1'),
- ('\U0000aab5', '\U0000aab6'),
- ('\U0000aab9', '\U0000aabd'),
- ('\U0000aac0', '\U0000aac0'),
- ('\U0000aac2', '\U0000aac2'),
- ('\U0000aadb', '\U0000aadc'),
- ('\U0000aae0', '\U0000aaea'),
- ('\U0000aaf2', '\U0000aaf2'),
- ('\U0000ab01', '\U0000ab06'),
- ('\U0000ab09', '\U0000ab0e'),
- ('\U0000ab11', '\U0000ab16'),
- ('\U0000ab20', '\U0000ab26'),
- ('\U0000ab28', '\U0000ab2e'),
- ('\U0000abc0', '\U0000abe2'),
- ('\U0000ac00', '\U0000ac00'),
- ('\U0000d7a3', '\U0000d7a3'),
- ('\U0000d7b0', '\U0000d7c6'),
- ('\U0000d7cb', '\U0000d7fb'),
- ('\U0000f900', '\U0000fa6d'),
- ('\U0000fa70', '\U0000fad9'),
- ('\U0000fb1d', '\U0000fb1d'),
- ('\U0000fb1f', '\U0000fb28'),
- ('\U0000fb2a', '\U0000fb36'),
- ('\U0000fb38', '\U0000fb3c'),
- ('\U0000fb3e', '\U0000fb3e'),
- ('\U0000fb40', '\U0000fb41'),
- ('\U0000fb43', '\U0000fb44'),
- ('\U0000fb46', '\U0000fbb1'),
- ('\U0000fbd3', '\U0000fd3d'),
- ('\U0000fd50', '\U0000fd8f'),
- ('\U0000fd92', '\U0000fdc7'),
- ('\U0000fdf0', '\U0000fdfb'),
- ('\U0000fe70', '\U0000fe74'),
- ('\U0000fe76', '\U0000fefc'),
- ('\U0000ff66', '\U0000ff6f'),
- ('\U0000ff71', '\U0000ff9d'),
- ('\U0000ffa0', '\U0000ffbe'),
- ('\U0000ffc2', '\U0000ffc7'),
- ('\U0000ffca', '\U0000ffcf'),
- ('\U0000ffd2', '\U0000ffd7'),
- ('\U0000ffda', '\U0000ffdc'),
- ('\U00010000', '\U0001000b'),
- ('\U0001000d', '\U00010026'),
- ('\U00010028', '\U0001003a'),
- ('\U0001003c', '\U0001003d'),
- ('\U0001003f', '\U0001004d'),
- ('\U00010050', '\U0001005d'),
- ('\U00010080', '\U000100fa'),
- ('\U00010280', '\U0001029c'),
- ('\U000102a0', '\U000102d0'),
- ('\U00010300', '\U0001031e'),
- ('\U00010330', '\U00010340'),
- ('\U00010342', '\U00010349'),
- ('\U00010380', '\U0001039d'),
- ('\U000103a0', '\U000103c3'),
- ('\U000103c8', '\U000103cf'),
- ('\U00010450', '\U0001049d'),
- ('\U00010800', '\U00010805'),
- ('\U00010808', '\U00010808'),
- ('\U0001080a', '\U00010835'),
- ('\U00010837', '\U00010838'),
- ('\U0001083c', '\U0001083c'),
- ('\U0001083f', '\U00010855'),
- ('\U00010900', '\U00010915'),
- ('\U00010920', '\U00010939'),
- ('\U00010980', '\U000109b7'),
- ('\U000109be', '\U000109bf'),
- ('\U00010a00', '\U00010a00'),
- ('\U00010a10', '\U00010a13'),
- ('\U00010a15', '\U00010a17'),
- ('\U00010a19', '\U00010a33'),
- ('\U00010a60', '\U00010a7c'),
- ('\U00010b00', '\U00010b35'),
- ('\U00010b40', '\U00010b55'),
- ('\U00010b60', '\U00010b72'),
- ('\U00010c00', '\U00010c48'),
- ('\U00011003', '\U00011037'),
- ('\U00011083', '\U000110af'),
- ('\U000110d0', '\U000110e8'),
- ('\U00011103', '\U00011126'),
- ('\U00011183', '\U000111b2'),
- ('\U000111c1', '\U000111c4'),
- ('\U00011680', '\U000116aa'),
- ('\U00012000', '\U0001236e'),
- ('\U00013000', '\U0001342e'),
- ('\U00016800', '\U00016a38'),
- ('\U00016f00', '\U00016f44'),
- ('\U00016f50', '\U00016f50'),
- ('\U0001b000', '\U0001b001'),
- ('\U0001ee00', '\U0001ee03'),
- ('\U0001ee05', '\U0001ee1f'),
- ('\U0001ee21', '\U0001ee22'),
- ('\U0001ee24', '\U0001ee24'),
- ('\U0001ee27', '\U0001ee27'),
- ('\U0001ee29', '\U0001ee32'),
- ('\U0001ee34', '\U0001ee37'),
- ('\U0001ee39', '\U0001ee39'),
- ('\U0001ee3b', '\U0001ee3b'),
- ('\U0001ee42', '\U0001ee42'),
- ('\U0001ee47', '\U0001ee47'),
- ('\U0001ee49', '\U0001ee49'),
- ('\U0001ee4b', '\U0001ee4b'),
- ('\U0001ee4d', '\U0001ee4f'),
- ('\U0001ee51', '\U0001ee52'),
- ('\U0001ee54', '\U0001ee54'),
- ('\U0001ee57', '\U0001ee57'),
- ('\U0001ee59', '\U0001ee59'),
- ('\U0001ee5b', '\U0001ee5b'),
- ('\U0001ee5d', '\U0001ee5d'),
- ('\U0001ee5f', '\U0001ee5f'),
- ('\U0001ee61', '\U0001ee62'),
- ('\U0001ee64', '\U0001ee64'),
- ('\U0001ee67', '\U0001ee6a'),
- ('\U0001ee6c', '\U0001ee72'),
- ('\U0001ee74', '\U0001ee77'),
- ('\U0001ee79', '\U0001ee7c'),
- ('\U0001ee7e', '\U0001ee7e'),
- ('\U0001ee80', '\U0001ee89'),
- ('\U0001ee8b', '\U0001ee9b'),
- ('\U0001eea1', '\U0001eea3'),
- ('\U0001eea5', '\U0001eea9'),
- ('\U0001eeab', '\U0001eebb'),
- ('\U00020000', '\U00020000'),
- ('\U0002a6d6', '\U0002a6d6'),
- ('\U0002a700', '\U0002a700'),
- ('\U0002b734', '\U0002b734'),
- ('\U0002b740', '\U0002b740'),
- ('\U0002b81d', '\U0002b81d'),
- ('\U0002f800', '\U0002fa1d')
- ]),
-("Lt", &[
- ('\U000001c5', '\U000001c5'),
- ('\U000001c8', '\U000001c8'),
- ('\U000001cb', '\U000001cb'),
- ('\U000001f2', '\U000001f2'),
- ('\U00001f88', '\U00001f8f'),
- ('\U00001f98', '\U00001f9f'),
- ('\U00001fa8', '\U00001faf'),
- ('\U00001fbc', '\U00001fbc'),
- ('\U00001fcc', '\U00001fcc'),
- ('\U00001ffc', '\U00001ffc')
- ]),
-("Lu", &[
- ('\U00000041', '\U0000005a'),
- ('\U000000c0', '\U000000d6'),
- ('\U000000d8', '\U000000de'),
- ('\U00000100', '\U00000100'),
- ('\U00000102', '\U00000102'),
- ('\U00000104', '\U00000104'),
- ('\U00000106', '\U00000106'),
- ('\U00000108', '\U00000108'),
- ('\U0000010a', '\U0000010a'),
- ('\U0000010c', '\U0000010c'),
- ('\U0000010e', '\U0000010e'),
- ('\U00000110', '\U00000110'),
- ('\U00000112', '\U00000112'),
- ('\U00000114', '\U00000114'),
- ('\U00000116', '\U00000116'),
- ('\U00000118', '\U00000118'),
- ('\U0000011a', '\U0000011a'),
- ('\U0000011c', '\U0000011c'),
- ('\U0000011e', '\U0000011e'),
- ('\U00000120', '\U00000120'),
- ('\U00000122', '\U00000122'),
- ('\U00000124', '\U00000124'),
- ('\U00000126', '\U00000126'),
- ('\U00000128', '\U00000128'),
- ('\U0000012a', '\U0000012a'),
- ('\U0000012c', '\U0000012c'),
- ('\U0000012e', '\U0000012e'),
- ('\U00000130', '\U00000130'),
- ('\U00000132', '\U00000132'),
- ('\U00000134', '\U00000134'),
- ('\U00000136', '\U00000136'),
- ('\U00000139', '\U00000139'),
- ('\U0000013b', '\U0000013b'),
- ('\U0000013d', '\U0000013d'),
- ('\U0000013f', '\U0000013f'),
- ('\U00000141', '\U00000141'),
- ('\U00000143', '\U00000143'),
- ('\U00000145', '\U00000145'),
- ('\U00000147', '\U00000147'),
- ('\U0000014a', '\U0000014a'),
- ('\U0000014c', '\U0000014c'),
- ('\U0000014e', '\U0000014e'),
- ('\U00000150', '\U00000150'),
- ('\U00000152', '\U00000152'),
- ('\U00000154', '\U00000154'),
- ('\U00000156', '\U00000156'),
- ('\U00000158', '\U00000158'),
- ('\U0000015a', '\U0000015a'),
- ('\U0000015c', '\U0000015c'),
- ('\U0000015e', '\U0000015e'),
- ('\U00000160', '\U00000160'),
- ('\U00000162', '\U00000162'),
- ('\U00000164', '\U00000164'),
- ('\U00000166', '\U00000166'),
- ('\U00000168', '\U00000168'),
- ('\U0000016a', '\U0000016a'),
- ('\U0000016c', '\U0000016c'),
- ('\U0000016e', '\U0000016e'),
- ('\U00000170', '\U00000170'),
- ('\U00000172', '\U00000172'),
- ('\U00000174', '\U00000174'),
- ('\U00000176', '\U00000176'),
- ('\U00000178', '\U00000179'),
- ('\U0000017b', '\U0000017b'),
- ('\U0000017d', '\U0000017d'),
- ('\U00000181', '\U00000182'),
- ('\U00000184', '\U00000184'),
- ('\U00000186', '\U00000187'),
- ('\U00000189', '\U0000018b'),
- ('\U0000018e', '\U00000191'),
- ('\U00000193', '\U00000194'),
- ('\U00000196', '\U00000198'),
- ('\U0000019c', '\U0000019d'),
- ('\U0000019f', '\U000001a0'),
- ('\U000001a2', '\U000001a2'),
- ('\U000001a4', '\U000001a4'),
- ('\U000001a6', '\U000001a7'),
- ('\U000001a9', '\U000001a9'),
- ('\U000001ac', '\U000001ac'),
- ('\U000001ae', '\U000001af'),
- ('\U000001b1', '\U000001b3'),
- ('\U000001b5', '\U000001b5'),
- ('\U000001b7', '\U000001b8'),
- ('\U000001bc', '\U000001bc'),
- ('\U000001c4', '\U000001c4'),
- ('\U000001c7', '\U000001c7'),
- ('\U000001ca', '\U000001ca'),
- ('\U000001cd', '\U000001cd'),
- ('\U000001cf', '\U000001cf'),
- ('\U000001d1', '\U000001d1'),
- ('\U000001d3', '\U000001d3'),
- ('\U000001d5', '\U000001d5'),
- ('\U000001d7', '\U000001d7'),
- ('\U000001d9', '\U000001d9'),
- ('\U000001db', '\U000001db'),
- ('\U000001de', '\U000001de'),
- ('\U000001e0', '\U000001e0'),
- ('\U000001e2', '\U000001e2'),
- ('\U000001e4', '\U000001e4'),
- ('\U000001e6', '\U000001e6'),
- ('\U000001e8', '\U000001e8'),
- ('\U000001ea', '\U000001ea'),
- ('\U000001ec', '\U000001ec'),
- ('\U000001ee', '\U000001ee'),
- ('\U000001f1', '\U000001f1'),
- ('\U000001f4', '\U000001f4'),
- ('\U000001f6', '\U000001f8'),
- ('\U000001fa', '\U000001fa'),
- ('\U000001fc', '\U000001fc'),
- ('\U000001fe', '\U000001fe'),
- ('\U00000200', '\U00000200'),
- ('\U00000202', '\U00000202'),
- ('\U00000204', '\U00000204'),
- ('\U00000206', '\U00000206'),
- ('\U00000208', '\U00000208'),
- ('\U0000020a', '\U0000020a'),
- ('\U0000020c', '\U0000020c'),
- ('\U0000020e', '\U0000020e'),
- ('\U00000210', '\U00000210'),
- ('\U00000212', '\U00000212'),
- ('\U00000214', '\U00000214'),
- ('\U00000216', '\U00000216'),
- ('\U00000218', '\U00000218'),
- ('\U0000021a', '\U0000021a'),
- ('\U0000021c', '\U0000021c'),
- ('\U0000021e', '\U0000021e'),
- ('\U00000220', '\U00000220'),
- ('\U00000222', '\U00000222'),
- ('\U00000224', '\U00000224'),
- ('\U00000226', '\U00000226'),
- ('\U00000228', '\U00000228'),
- ('\U0000022a', '\U0000022a'),
- ('\U0000022c', '\U0000022c'),
- ('\U0000022e', '\U0000022e'),
- ('\U00000230', '\U00000230'),
- ('\U00000232', '\U00000232'),
- ('\U0000023a', '\U0000023b'),
- ('\U0000023d', '\U0000023e'),
- ('\U00000241', '\U00000241'),
- ('\U00000243', '\U00000246'),
- ('\U00000248', '\U00000248'),
- ('\U0000024a', '\U0000024a'),
- ('\U0000024c', '\U0000024c'),
- ('\U0000024e', '\U0000024e'),
- ('\U00000370', '\U00000370'),
- ('\U00000372', '\U00000372'),
- ('\U00000376', '\U00000376'),
- ('\U00000386', '\U00000386'),
- ('\U00000388', '\U0000038a'),
- ('\U0000038c', '\U0000038c'),
- ('\U0000038e', '\U0000038f'),
- ('\U00000391', '\U000003a1'),
- ('\U000003a3', '\U000003ab'),
- ('\U000003cf', '\U000003cf'),
- ('\U000003d2', '\U000003d4'),
- ('\U000003d8', '\U000003d8'),
- ('\U000003da', '\U000003da'),
- ('\U000003dc', '\U000003dc'),
- ('\U000003de', '\U000003de'),
- ('\U000003e0', '\U000003e0'),
- ('\U000003e2', '\U000003e2'),
- ('\U000003e4', '\U000003e4'),
- ('\U000003e6', '\U000003e6'),
- ('\U000003e8', '\U000003e8'),
- ('\U000003ea', '\U000003ea'),
- ('\U000003ec', '\U000003ec'),
- ('\U000003ee', '\U000003ee'),
- ('\U000003f4', '\U000003f4'),
- ('\U000003f7', '\U000003f7'),
- ('\U000003f9', '\U000003fa'),
- ('\U000003fd', '\U0000042f'),
- ('\U00000460', '\U00000460'),
- ('\U00000462', '\U00000462'),
- ('\U00000464', '\U00000464'),
- ('\U00000466', '\U00000466'),
- ('\U00000468', '\U00000468'),
- ('\U0000046a', '\U0000046a'),
- ('\U0000046c', '\U0000046c'),
- ('\U0000046e', '\U0000046e'),
- ('\U00000470', '\U00000470'),
- ('\U00000472', '\U00000472'),
- ('\U00000474', '\U00000474'),
- ('\U00000476', '\U00000476'),
- ('\U00000478', '\U00000478'),
- ('\U0000047a', '\U0000047a'),
- ('\U0000047c', '\U0000047c'),
- ('\U0000047e', '\U0000047e'),
- ('\U00000480', '\U00000480'),
- ('\U0000048a', '\U0000048a'),
- ('\U0000048c', '\U0000048c'),
- ('\U0000048e', '\U0000048e'),
- ('\U00000490', '\U00000490'),
- ('\U00000492', '\U00000492'),
- ('\U00000494', '\U00000494'),
- ('\U00000496', '\U00000496'),
- ('\U00000498', '\U00000498'),
- ('\U0000049a', '\U0000049a'),
- ('\U0000049c', '\U0000049c'),
- ('\U0000049e', '\U0000049e'),
- ('\U000004a0', '\U000004a0'),
- ('\U000004a2', '\U000004a2'),
- ('\U000004a4', '\U000004a4'),
- ('\U000004a6', '\U000004a6'),
- ('\U000004a8', '\U000004a8'),
- ('\U000004aa', '\U000004aa'),
- ('\U000004ac', '\U000004ac'),
- ('\U000004ae', '\U000004ae'),
- ('\U000004b0', '\U000004b0'),
- ('\U000004b2', '\U000004b2'),
- ('\U000004b4', '\U000004b4'),
- ('\U000004b6', '\U000004b6'),
- ('\U000004b8', '\U000004b8'),
- ('\U000004ba', '\U000004ba'),
- ('\U000004bc', '\U000004bc'),
- ('\U000004be', '\U000004be'),
- ('\U000004c0', '\U000004c1'),
- ('\U000004c3', '\U000004c3'),
- ('\U000004c5', '\U000004c5'),
- ('\U000004c7', '\U000004c7'),
- ('\U000004c9', '\U000004c9'),
- ('\U000004cb', '\U000004cb'),
- ('\U000004cd', '\U000004cd'),
- ('\U000004d0', '\U000004d0'),
- ('\U000004d2', '\U000004d2'),
- ('\U000004d4', '\U000004d4'),
- ('\U000004d6', '\U000004d6'),
- ('\U000004d8', '\U000004d8'),
- ('\U000004da', '\U000004da'),
- ('\U000004dc', '\U000004dc'),
- ('\U000004de', '\U000004de'),
- ('\U000004e0', '\U000004e0'),
- ('\U000004e2', '\U000004e2'),
- ('\U000004e4', '\U000004e4'),
- ('\U000004e6', '\U000004e6'),
- ('\U000004e8', '\U000004e8'),
- ('\U000004ea', '\U000004ea'),
- ('\U000004ec', '\U000004ec'),
- ('\U000004ee', '\U000004ee'),
- ('\U000004f0', '\U000004f0'),
- ('\U000004f2', '\U000004f2'),
- ('\U000004f4', '\U000004f4'),
- ('\U000004f6', '\U000004f6'),
- ('\U000004f8', '\U000004f8'),
- ('\U000004fa', '\U000004fa'),
- ('\U000004fc', '\U000004fc'),
- ('\U000004fe', '\U000004fe'),
- ('\U00000500', '\U00000500'),
- ('\U00000502', '\U00000502'),
- ('\U00000504', '\U00000504'),
- ('\U00000506', '\U00000506'),
- ('\U00000508', '\U00000508'),
- ('\U0000050a', '\U0000050a'),
- ('\U0000050c', '\U0000050c'),
- ('\U0000050e', '\U0000050e'),
- ('\U00000510', '\U00000510'),
- ('\U00000512', '\U00000512'),
- ('\U00000514', '\U00000514'),
- ('\U00000516', '\U00000516'),
- ('\U00000518', '\U00000518'),
- ('\U0000051a', '\U0000051a'),
- ('\U0000051c', '\U0000051c'),
- ('\U0000051e', '\U0000051e'),
- ('\U00000520', '\U00000520'),
- ('\U00000522', '\U00000522'),
- ('\U00000524', '\U00000524'),
- ('\U00000526', '\U00000526'),
- ('\U00000531', '\U00000556'),
- ('\U000010a0', '\U000010c5'),
- ('\U000010c7', '\U000010c7'),
- ('\U000010cd', '\U000010cd'),
- ('\U00001e00', '\U00001e00'),
- ('\U00001e02', '\U00001e02'),
- ('\U00001e04', '\U00001e04'),
- ('\U00001e06', '\U00001e06'),
- ('\U00001e08', '\U00001e08'),
- ('\U00001e0a', '\U00001e0a'),
- ('\U00001e0c', '\U00001e0c'),
- ('\U00001e0e', '\U00001e0e'),
- ('\U00001e10', '\U00001e10'),
- ('\U00001e12', '\U00001e12'),
- ('\U00001e14', '\U00001e14'),
- ('\U00001e16', '\U00001e16'),
- ('\U00001e18', '\U00001e18'),
- ('\U00001e1a', '\U00001e1a'),
- ('\U00001e1c', '\U00001e1c'),
- ('\U00001e1e', '\U00001e1e'),
- ('\U00001e20', '\U00001e20'),
- ('\U00001e22', '\U00001e22'),
- ('\U00001e24', '\U00001e24'),
- ('\U00001e26', '\U00001e26'),
- ('\U00001e28', '\U00001e28'),
- ('\U00001e2a', '\U00001e2a'),
- ('\U00001e2c', '\U00001e2c'),
- ('\U00001e2e', '\U00001e2e'),
- ('\U00001e30', '\U00001e30'),
- ('\U00001e32', '\U00001e32'),
- ('\U00001e34', '\U00001e34'),
- ('\U00001e36', '\U00001e36'),
- ('\U00001e38', '\U00001e38'),
- ('\U00001e3a', '\U00001e3a'),
- ('\U00001e3c', '\U00001e3c'),
- ('\U00001e3e', '\U00001e3e'),
- ('\U00001e40', '\U00001e40'),
- ('\U00001e42', '\U00001e42'),
- ('\U00001e44', '\U00001e44'),
- ('\U00001e46', '\U00001e46'),
- ('\U00001e48', '\U00001e48'),
- ('\U00001e4a', '\U00001e4a'),
- ('\U00001e4c', '\U00001e4c'),
- ('\U00001e4e', '\U00001e4e'),
- ('\U00001e50', '\U00001e50'),
- ('\U00001e52', '\U00001e52'),
- ('\U00001e54', '\U00001e54'),
- ('\U00001e56', '\U00001e56'),
- ('\U00001e58', '\U00001e58'),
- ('\U00001e5a', '\U00001e5a'),
- ('\U00001e5c', '\U00001e5c'),
- ('\U00001e5e', '\U00001e5e'),
- ('\U00001e60', '\U00001e60'),
- ('\U00001e62', '\U00001e62'),
- ('\U00001e64', '\U00001e64'),
- ('\U00001e66', '\U00001e66'),
- ('\U00001e68', '\U00001e68'),
- ('\U00001e6a', '\U00001e6a'),
- ('\U00001e6c', '\U00001e6c'),
- ('\U00001e6e', '\U00001e6e'),
- ('\U00001e70', '\U00001e70'),
- ('\U00001e72', '\U00001e72'),
- ('\U00001e74', '\U00001e74'),
- ('\U00001e76', '\U00001e76'),
- ('\U00001e78', '\U00001e78'),
- ('\U00001e7a', '\U00001e7a'),
- ('\U00001e7c', '\U00001e7c'),
- ('\U00001e7e', '\U00001e7e'),
- ('\U00001e80', '\U00001e80'),
- ('\U00001e82', '\U00001e82'),
- ('\U00001e84', '\U00001e84'),
- ('\U00001e86', '\U00001e86'),
- ('\U00001e88', '\U00001e88'),
- ('\U00001e8a', '\U00001e8a'),
- ('\U00001e8c', '\U00001e8c'),
- ('\U00001e8e', '\U00001e8e'),
- ('\U00001e90', '\U00001e90'),
- ('\U00001e92', '\U00001e92'),
- ('\U00001e94', '\U00001e94'),
- ('\U00001e9e', '\U00001e9e'),
- ('\U00001ea0', '\U00001ea0'),
- ('\U00001ea2', '\U00001ea2'),
- ('\U00001ea4', '\U00001ea4'),
- ('\U00001ea6', '\U00001ea6'),
- ('\U00001ea8', '\U00001ea8'),
- ('\U00001eaa', '\U00001eaa'),
- ('\U00001eac', '\U00001eac'),
- ('\U00001eae', '\U00001eae'),
- ('\U00001eb0', '\U00001eb0'),
- ('\U00001eb2', '\U00001eb2'),
- ('\U00001eb4', '\U00001eb4'),
- ('\U00001eb6', '\U00001eb6'),
- ('\U00001eb8', '\U00001eb8'),
- ('\U00001eba', '\U00001eba'),
- ('\U00001ebc', '\U00001ebc'),
- ('\U00001ebe', '\U00001ebe'),
- ('\U00001ec0', '\U00001ec0'),
- ('\U00001ec2', '\U00001ec2'),
- ('\U00001ec4', '\U00001ec4'),
- ('\U00001ec6', '\U00001ec6'),
- ('\U00001ec8', '\U00001ec8'),
- ('\U00001eca', '\U00001eca'),
- ('\U00001ecc', '\U00001ecc'),
- ('\U00001ece', '\U00001ece'),
- ('\U00001ed0', '\U00001ed0'),
- ('\U00001ed2', '\U00001ed2'),
- ('\U00001ed4', '\U00001ed4'),
- ('\U00001ed6', '\U00001ed6'),
- ('\U00001ed8', '\U00001ed8'),
- ('\U00001eda', '\U00001eda'),
- ('\U00001edc', '\U00001edc'),
- ('\U00001ede', '\U00001ede'),
- ('\U00001ee0', '\U00001ee0'),
- ('\U00001ee2', '\U00001ee2'),
- ('\U00001ee4', '\U00001ee4'),
- ('\U00001ee6', '\U00001ee6'),
- ('\U00001ee8', '\U00001ee8'),
- ('\U00001eea', '\U00001eea'),
- ('\U00001eec', '\U00001eec'),
- ('\U00001eee', '\U00001eee'),
- ('\U00001ef0', '\U00001ef0'),
- ('\U00001ef2', '\U00001ef2'),
- ('\U00001ef4', '\U00001ef4'),
- ('\U00001ef6', '\U00001ef6'),
- ('\U00001ef8', '\U00001ef8'),
- ('\U00001efa', '\U00001efa'),
- ('\U00001efc', '\U00001efc'),
- ('\U00001efe', '\U00001efe'),
- ('\U00001f08', '\U00001f0f'),
- ('\U00001f18', '\U00001f1d'),
- ('\U00001f28', '\U00001f2f'),
- ('\U00001f38', '\U00001f3f'),
- ('\U00001f48', '\U00001f4d'),
- ('\U00001f59', '\U00001f59'),
- ('\U00001f5b', '\U00001f5b'),
- ('\U00001f5d', '\U00001f5d'),
- ('\U00001f5f', '\U00001f5f'),
- ('\U00001f68', '\U00001f6f'),
- ('\U00001fb8', '\U00001fbb'),
- ('\U00001fc8', '\U00001fcb'),
- ('\U00001fd8', '\U00001fdb'),
- ('\U00001fe8', '\U00001fec'),
- ('\U00001ff8', '\U00001ffb'),
- ('\U00002102', '\U00002102'),
- ('\U00002107', '\U00002107'),
- ('\U0000210b', '\U0000210d'),
- ('\U00002110', '\U00002112'),
- ('\U00002115', '\U00002115'),
- ('\U00002119', '\U0000211d'),
- ('\U00002124', '\U00002124'),
- ('\U00002126', '\U00002126'),
- ('\U00002128', '\U00002128'),
- ('\U0000212a', '\U0000212d'),
- ('\U00002130', '\U00002133'),
- ('\U0000213e', '\U0000213f'),
- ('\U00002145', '\U00002145'),
- ('\U00002183', '\U00002183'),
- ('\U00002c00', '\U00002c2e'),
- ('\U00002c60', '\U00002c60'),
- ('\U00002c62', '\U00002c64'),
- ('\U00002c67', '\U00002c67'),
- ('\U00002c69', '\U00002c69'),
- ('\U00002c6b', '\U00002c6b'),
- ('\U00002c6d', '\U00002c70'),
- ('\U00002c72', '\U00002c72'),
- ('\U00002c75', '\U00002c75'),
- ('\U00002c7e', '\U00002c80'),
- ('\U00002c82', '\U00002c82'),
- ('\U00002c84', '\U00002c84'),
- ('\U00002c86', '\U00002c86'),
- ('\U00002c88', '\U00002c88'),
- ('\U00002c8a', '\U00002c8a'),
- ('\U00002c8c', '\U00002c8c'),
- ('\U00002c8e', '\U00002c8e'),
- ('\U00002c90', '\U00002c90'),
- ('\U00002c92', '\U00002c92'),
- ('\U00002c94', '\U00002c94'),
- ('\U00002c96', '\U00002c96'),
- ('\U00002c98', '\U00002c98'),
- ('\U00002c9a', '\U00002c9a'),
- ('\U00002c9c', '\U00002c9c'),
- ('\U00002c9e', '\U00002c9e'),
- ('\U00002ca0', '\U00002ca0'),
- ('\U00002ca2', '\U00002ca2'),
- ('\U00002ca4', '\U00002ca4'),
- ('\U00002ca6', '\U00002ca6'),
- ('\U00002ca8', '\U00002ca8'),
- ('\U00002caa', '\U00002caa'),
- ('\U00002cac', '\U00002cac'),
- ('\U00002cae', '\U00002cae'),
- ('\U00002cb0', '\U00002cb0'),
- ('\U00002cb2', '\U00002cb2'),
- ('\U00002cb4', '\U00002cb4'),
- ('\U00002cb6', '\U00002cb6'),
- ('\U00002cb8', '\U00002cb8'),
- ('\U00002cba', '\U00002cba'),
- ('\U00002cbc', '\U00002cbc'),
- ('\U00002cbe', '\U00002cbe'),
- ('\U00002cc0', '\U00002cc0'),
- ('\U00002cc2', '\U00002cc2'),
- ('\U00002cc4', '\U00002cc4'),
- ('\U00002cc6', '\U00002cc6'),
- ('\U00002cc8', '\U00002cc8'),
- ('\U00002cca', '\U00002cca'),
- ('\U00002ccc', '\U00002ccc'),
- ('\U00002cce', '\U00002cce'),
- ('\U00002cd0', '\U00002cd0'),
- ('\U00002cd2', '\U00002cd2'),
- ('\U00002cd4', '\U00002cd4'),
- ('\U00002cd6', '\U00002cd6'),
- ('\U00002cd8', '\U00002cd8'),
- ('\U00002cda', '\U00002cda'),
- ('\U00002cdc', '\U00002cdc'),
- ('\U00002cde', '\U00002cde'),
- ('\U00002ce0', '\U00002ce0'),
- ('\U00002ce2', '\U00002ce2'),
- ('\U00002ceb', '\U00002ceb'),
- ('\U00002ced', '\U00002ced'),
- ('\U00002cf2', '\U00002cf2'),
- ('\U0000a640', '\U0000a640'),
- ('\U0000a642', '\U0000a642'),
- ('\U0000a644', '\U0000a644'),
- ('\U0000a646', '\U0000a646'),
- ('\U0000a648', '\U0000a648'),
- ('\U0000a64a', '\U0000a64a'),
- ('\U0000a64c', '\U0000a64c'),
- ('\U0000a64e', '\U0000a64e'),
- ('\U0000a650', '\U0000a650'),
- ('\U0000a652', '\U0000a652'),
- ('\U0000a654', '\U0000a654'),
- ('\U0000a656', '\U0000a656'),
- ('\U0000a658', '\U0000a658'),
- ('\U0000a65a', '\U0000a65a'),
- ('\U0000a65c', '\U0000a65c'),
- ('\U0000a65e', '\U0000a65e'),
- ('\U0000a660', '\U0000a660'),
- ('\U0000a662', '\U0000a662'),
- ('\U0000a664', '\U0000a664'),
- ('\U0000a666', '\U0000a666'),
- ('\U0000a668', '\U0000a668'),
- ('\U0000a66a', '\U0000a66a'),
- ('\U0000a66c', '\U0000a66c'),
- ('\U0000a680', '\U0000a680'),
- ('\U0000a682', '\U0000a682'),
- ('\U0000a684', '\U0000a684'),
- ('\U0000a686', '\U0000a686'),
- ('\U0000a688', '\U0000a688'),
- ('\U0000a68a', '\U0000a68a'),
- ('\U0000a68c', '\U0000a68c'),
- ('\U0000a68e', '\U0000a68e'),
- ('\U0000a690', '\U0000a690'),
- ('\U0000a692', '\U0000a692'),
- ('\U0000a694', '\U0000a694'),
- ('\U0000a696', '\U0000a696'),
- ('\U0000a722', '\U0000a722'),
- ('\U0000a724', '\U0000a724'),
- ('\U0000a726', '\U0000a726'),
- ('\U0000a728', '\U0000a728'),
- ('\U0000a72a', '\U0000a72a'),
- ('\U0000a72c', '\U0000a72c'),
- ('\U0000a72e', '\U0000a72e'),
- ('\U0000a732', '\U0000a732'),
- ('\U0000a734', '\U0000a734'),
- ('\U0000a736', '\U0000a736'),
- ('\U0000a738', '\U0000a738'),
- ('\U0000a73a', '\U0000a73a'),
- ('\U0000a73c', '\U0000a73c'),
- ('\U0000a73e', '\U0000a73e'),
- ('\U0000a740', '\U0000a740'),
- ('\U0000a742', '\U0000a742'),
- ('\U0000a744', '\U0000a744'),
- ('\U0000a746', '\U0000a746'),
- ('\U0000a748', '\U0000a748'),
- ('\U0000a74a', '\U0000a74a'),
- ('\U0000a74c', '\U0000a74c'),
- ('\U0000a74e', '\U0000a74e'),
- ('\U0000a750', '\U0000a750'),
- ('\U0000a752', '\U0000a752'),
- ('\U0000a754', '\U0000a754'),
- ('\U0000a756', '\U0000a756'),
- ('\U0000a758', '\U0000a758'),
- ('\U0000a75a', '\U0000a75a'),
- ('\U0000a75c', '\U0000a75c'),
- ('\U0000a75e', '\U0000a75e'),
- ('\U0000a760', '\U0000a760'),
- ('\U0000a762', '\U0000a762'),
- ('\U0000a764', '\U0000a764'),
- ('\U0000a766', '\U0000a766'),
- ('\U0000a768', '\U0000a768'),
- ('\U0000a76a', '\U0000a76a'),
- ('\U0000a76c', '\U0000a76c'),
- ('\U0000a76e', '\U0000a76e'),
- ('\U0000a779', '\U0000a779'),
- ('\U0000a77b', '\U0000a77b'),
- ('\U0000a77d', '\U0000a77e'),
- ('\U0000a780', '\U0000a780'),
- ('\U0000a782', '\U0000a782'),
- ('\U0000a784', '\U0000a784'),
- ('\U0000a786', '\U0000a786'),
- ('\U0000a78b', '\U0000a78b'),
- ('\U0000a78d', '\U0000a78d'),
- ('\U0000a790', '\U0000a790'),
- ('\U0000a792', '\U0000a792'),
- ('\U0000a7a0', '\U0000a7a0'),
- ('\U0000a7a2', '\U0000a7a2'),
- ('\U0000a7a4', '\U0000a7a4'),
- ('\U0000a7a6', '\U0000a7a6'),
- ('\U0000a7a8', '\U0000a7a8'),
- ('\U0000a7aa', '\U0000a7aa'),
- ('\U0000ff21', '\U0000ff3a'),
- ('\U00010400', '\U00010427'),
- ('\U0001d400', '\U0001d419'),
- ('\U0001d434', '\U0001d44d'),
- ('\U0001d468', '\U0001d481'),
- ('\U0001d49c', '\U0001d49c'),
- ('\U0001d49e', '\U0001d49f'),
- ('\U0001d4a2', '\U0001d4a2'),
- ('\U0001d4a5', '\U0001d4a6'),
- ('\U0001d4a9', '\U0001d4ac'),
- ('\U0001d4ae', '\U0001d4b5'),
- ('\U0001d4d0', '\U0001d4e9'),
- ('\U0001d504', '\U0001d505'),
- ('\U0001d507', '\U0001d50a'),
- ('\U0001d50d', '\U0001d514'),
- ('\U0001d516', '\U0001d51c'),
- ('\U0001d538', '\U0001d539'),
- ('\U0001d53b', '\U0001d53e'),
- ('\U0001d540', '\U0001d544'),
- ('\U0001d546', '\U0001d546'),
- ('\U0001d54a', '\U0001d550'),
- ('\U0001d56c', '\U0001d585'),
- ('\U0001d5a0', '\U0001d5b9'),
- ('\U0001d5d4', '\U0001d5ed'),
- ('\U0001d608', '\U0001d621'),
- ('\U0001d63c', '\U0001d655'),
- ('\U0001d670', '\U0001d689'),
- ('\U0001d6a8', '\U0001d6c0'),
- ('\U0001d6e2', '\U0001d6fa'),
- ('\U0001d71c', '\U0001d734'),
- ('\U0001d756', '\U0001d76e'),
- ('\U0001d790', '\U0001d7a8'),
- ('\U0001d7ca', '\U0001d7ca')
- ]),
-("Lycian", &[
- ('\U00010280', '\U0001029c')
- ]),
-("Lydian", &[
- ('\U00010920', '\U00010939'),
- ('\U0001093f', '\U0001093f')
- ]),
-("M", &[
- ('\U00000300', '\U0000036f'),
- ('\U00000483', '\U00000489'),
- ('\U00000591', '\U000005bd'),
- ('\U000005bf', '\U000005bf'),
- ('\U000005c1', '\U000005c2'),
- ('\U000005c4', '\U000005c5'),
- ('\U000005c7', '\U000005c7'),
- ('\U00000610', '\U0000061a'),
- ('\U0000064b', '\U0000065f'),
- ('\U00000670', '\U00000670'),
- ('\U000006d6', '\U000006dc'),
- ('\U000006df', '\U000006e4'),
- ('\U000006e7', '\U000006e8'),
- ('\U000006ea', '\U000006ed'),
- ('\U00000711', '\U00000711'),
- ('\U00000730', '\U0000074a'),
- ('\U000007a6', '\U000007b0'),
- ('\U000007eb', '\U000007f3'),
- ('\U00000816', '\U00000819'),
- ('\U0000081b', '\U00000823'),
- ('\U00000825', '\U00000827'),
- ('\U00000829', '\U0000082d'),
- ('\U00000859', '\U0000085b'),
- ('\U000008e4', '\U000008fe'),
- ('\U00000900', '\U00000903'),
- ('\U0000093a', '\U0000093c'),
- ('\U0000093e', '\U0000094f'),
- ('\U00000951', '\U00000957'),
- ('\U00000962', '\U00000963'),
- ('\U00000981', '\U00000983'),
- ('\U000009bc', '\U000009bc'),
- ('\U000009be', '\U000009c4'),
- ('\U000009c7', '\U000009c8'),
- ('\U000009cb', '\U000009cd'),
- ('\U000009d7', '\U000009d7'),
- ('\U000009e2', '\U000009e3'),
- ('\U00000a01', '\U00000a03'),
- ('\U00000a3c', '\U00000a3c'),
- ('\U00000a3e', '\U00000a42'),
- ('\U00000a47', '\U00000a48'),
- ('\U00000a4b', '\U00000a4d'),
- ('\U00000a51', '\U00000a51'),
- ('\U00000a70', '\U00000a71'),
- ('\U00000a75', '\U00000a75'),
- ('\U00000a81', '\U00000a83'),
- ('\U00000abc', '\U00000abc'),
- ('\U00000abe', '\U00000ac5'),
- ('\U00000ac7', '\U00000ac9'),
- ('\U00000acb', '\U00000acd'),
- ('\U00000ae2', '\U00000ae3'),
- ('\U00000b01', '\U00000b03'),
- ('\U00000b3c', '\U00000b3c'),
- ('\U00000b3e', '\U00000b44'),
- ('\U00000b47', '\U00000b48'),
- ('\U00000b4b', '\U00000b4d'),
- ('\U00000b56', '\U00000b57'),
- ('\U00000b62', '\U00000b63'),
- ('\U00000b82', '\U00000b82'),
- ('\U00000bbe', '\U00000bc2'),
- ('\U00000bc6', '\U00000bc8'),
- ('\U00000bca', '\U00000bcd'),
- ('\U00000bd7', '\U00000bd7'),
- ('\U00000c01', '\U00000c03'),
- ('\U00000c3e', '\U00000c44'),
- ('\U00000c46', '\U00000c48'),
- ('\U00000c4a', '\U00000c4d'),
- ('\U00000c55', '\U00000c56'),
- ('\U00000c62', '\U00000c63'),
- ('\U00000c82', '\U00000c83'),
- ('\U00000cbc', '\U00000cbc'),
- ('\U00000cbe', '\U00000cc4'),
- ('\U00000cc6', '\U00000cc8'),
- ('\U00000cca', '\U00000ccd'),
- ('\U00000cd5', '\U00000cd6'),
- ('\U00000ce2', '\U00000ce3'),
- ('\U00000d02', '\U00000d03'),
- ('\U00000d3e', '\U00000d44'),
- ('\U00000d46', '\U00000d48'),
- ('\U00000d4a', '\U00000d4d'),
- ('\U00000d57', '\U00000d57'),
- ('\U00000d62', '\U00000d63'),
- ('\U00000d82', '\U00000d83'),
- ('\U00000dca', '\U00000dca'),
- ('\U00000dcf', '\U00000dd4'),
- ('\U00000dd6', '\U00000dd6'),
- ('\U00000dd8', '\U00000ddf'),
- ('\U00000df2', '\U00000df3'),
- ('\U00000e31', '\U00000e31'),
- ('\U00000e34', '\U00000e3a'),
- ('\U00000e47', '\U00000e4e'),
- ('\U00000eb1', '\U00000eb1'),
- ('\U00000eb4', '\U00000eb9'),
- ('\U00000ebb', '\U00000ebc'),
- ('\U00000ec8', '\U00000ecd'),
- ('\U00000f18', '\U00000f19'),
- ('\U00000f35', '\U00000f35'),
- ('\U00000f37', '\U00000f37'),
- ('\U00000f39', '\U00000f39'),
- ('\U00000f3e', '\U00000f3f'),
- ('\U00000f71', '\U00000f84'),
- ('\U00000f86', '\U00000f87'),
- ('\U00000f8d', '\U00000f97'),
- ('\U00000f99', '\U00000fbc'),
- ('\U00000fc6', '\U00000fc6'),
- ('\U0000102b', '\U0000103e'),
- ('\U00001056', '\U00001059'),
- ('\U0000105e', '\U00001060'),
- ('\U00001062', '\U00001064'),
- ('\U00001067', '\U0000106d'),
- ('\U00001071', '\U00001074'),
- ('\U00001082', '\U0000108d'),
- ('\U0000108f', '\U0000108f'),
- ('\U0000109a', '\U0000109d'),
- ('\U0000135d', '\U0000135f'),
- ('\U00001712', '\U00001714'),
- ('\U00001732', '\U00001734'),
- ('\U00001752', '\U00001753'),
- ('\U00001772', '\U00001773'),
- ('\U000017b4', '\U000017d3'),
- ('\U000017dd', '\U000017dd'),
- ('\U0000180b', '\U0000180d'),
- ('\U000018a9', '\U000018a9'),
- ('\U00001920', '\U0000192b'),
- ('\U00001930', '\U0000193b'),
- ('\U000019b0', '\U000019c0'),
- ('\U000019c8', '\U000019c9'),
- ('\U00001a17', '\U00001a1b'),
- ('\U00001a55', '\U00001a5e'),
- ('\U00001a60', '\U00001a7c'),
- ('\U00001a7f', '\U00001a7f'),
- ('\U00001b00', '\U00001b04'),
- ('\U00001b34', '\U00001b44'),
- ('\U00001b6b', '\U00001b73'),
- ('\U00001b80', '\U00001b82'),
- ('\U00001ba1', '\U00001bad'),
- ('\U00001be6', '\U00001bf3'),
- ('\U00001c24', '\U00001c37'),
- ('\U00001cd0', '\U00001cd2'),
- ('\U00001cd4', '\U00001ce8'),
- ('\U00001ced', '\U00001ced'),
- ('\U00001cf2', '\U00001cf4'),
- ('\U00001dc0', '\U00001de6'),
- ('\U00001dfc', '\U00001dff'),
- ('\U000020d0', '\U000020f0'),
- ('\U00002cef', '\U00002cf1'),
- ('\U00002d7f', '\U00002d7f'),
- ('\U00002de0', '\U00002dff'),
- ('\U0000302a', '\U0000302f'),
- ('\U00003099', '\U0000309a'),
- ('\U0000a66f', '\U0000a672'),
- ('\U0000a674', '\U0000a67d'),
- ('\U0000a69f', '\U0000a69f'),
- ('\U0000a6f0', '\U0000a6f1'),
- ('\U0000a802', '\U0000a802'),
- ('\U0000a806', '\U0000a806'),
- ('\U0000a80b', '\U0000a80b'),
- ('\U0000a823', '\U0000a827'),
- ('\U0000a880', '\U0000a881'),
- ('\U0000a8b4', '\U0000a8c4'),
- ('\U0000a8e0', '\U0000a8f1'),
- ('\U0000a926', '\U0000a92d'),
- ('\U0000a947', '\U0000a953'),
- ('\U0000a980', '\U0000a983'),
- ('\U0000a9b3', '\U0000a9c0'),
- ('\U0000aa29', '\U0000aa36'),
- ('\U0000aa43', '\U0000aa43'),
- ('\U0000aa4c', '\U0000aa4d'),
- ('\U0000aa7b', '\U0000aa7b'),
- ('\U0000aab0', '\U0000aab0'),
- ('\U0000aab2', '\U0000aab4'),
- ('\U0000aab7', '\U0000aab8'),
- ('\U0000aabe', '\U0000aabf'),
- ('\U0000aac1', '\U0000aac1'),
- ('\U0000aaeb', '\U0000aaef'),
- ('\U0000aaf5', '\U0000aaf6'),
- ('\U0000abe3', '\U0000abea'),
- ('\U0000abec', '\U0000abed'),
- ('\U0000fb1e', '\U0000fb1e'),
- ('\U0000fe00', '\U0000fe0f'),
- ('\U0000fe20', '\U0000fe26'),
- ('\U000101fd', '\U000101fd'),
- ('\U00010a01', '\U00010a03'),
- ('\U00010a05', '\U00010a06'),
- ('\U00010a0c', '\U00010a0f'),
- ('\U00010a38', '\U00010a3a'),
- ('\U00010a3f', '\U00010a3f'),
- ('\U00011000', '\U00011002'),
- ('\U00011038', '\U00011046'),
- ('\U00011080', '\U00011082'),
- ('\U000110b0', '\U000110ba'),
- ('\U00011100', '\U00011102'),
- ('\U00011127', '\U00011134'),
- ('\U00011180', '\U00011182'),
- ('\U000111b3', '\U000111c0'),
- ('\U000116ab', '\U000116b7'),
- ('\U00016f51', '\U00016f7e'),
- ('\U00016f8f', '\U00016f92'),
- ('\U0001d165', '\U0001d169'),
- ('\U0001d16d', '\U0001d172'),
- ('\U0001d17b', '\U0001d182'),
- ('\U0001d185', '\U0001d18b'),
- ('\U0001d1aa', '\U0001d1ad'),
- ('\U0001d242', '\U0001d244'),
- ('\U000e0100', '\U000e01ef')
- ]),
-("Malayalam", &[
- ('\U00000d02', '\U00000d03'),
- ('\U00000d05', '\U00000d0c'),
- ('\U00000d0e', '\U00000d10'),
- ('\U00000d12', '\U00000d3a'),
- ('\U00000d3d', '\U00000d44'),
- ('\U00000d46', '\U00000d48'),
- ('\U00000d4a', '\U00000d4e'),
- ('\U00000d57', '\U00000d57'),
- ('\U00000d60', '\U00000d63'),
- ('\U00000d66', '\U00000d75'),
- ('\U00000d79', '\U00000d7f')
- ]),
-("Mandaic", &[
- ('\U00000840', '\U0000085b'),
- ('\U0000085e', '\U0000085e')
- ]),
-("Mc", &[
- ('\U00000903', '\U00000903'),
- ('\U0000093b', '\U0000093b'),
- ('\U0000093e', '\U00000940'),
- ('\U00000949', '\U0000094c'),
- ('\U0000094e', '\U0000094f'),
- ('\U00000982', '\U00000983'),
- ('\U000009be', '\U000009c0'),
- ('\U000009c7', '\U000009c8'),
- ('\U000009cb', '\U000009cc'),
- ('\U000009d7', '\U000009d7'),
- ('\U00000a03', '\U00000a03'),
- ('\U00000a3e', '\U00000a40'),
- ('\U00000a83', '\U00000a83'),
- ('\U00000abe', '\U00000ac0'),
- ('\U00000ac9', '\U00000ac9'),
- ('\U00000acb', '\U00000acc'),
- ('\U00000b02', '\U00000b03'),
- ('\U00000b3e', '\U00000b3e'),
- ('\U00000b40', '\U00000b40'),
- ('\U00000b47', '\U00000b48'),
- ('\U00000b4b', '\U00000b4c'),
- ('\U00000b57', '\U00000b57'),
- ('\U00000bbe', '\U00000bbf'),
- ('\U00000bc1', '\U00000bc2'),
- ('\U00000bc6', '\U00000bc8'),
- ('\U00000bca', '\U00000bcc'),
- ('\U00000bd7', '\U00000bd7'),
- ('\U00000c01', '\U00000c03'),
- ('\U00000c41', '\U00000c44'),
- ('\U00000c82', '\U00000c83'),
- ('\U00000cbe', '\U00000cbe'),
- ('\U00000cc0', '\U00000cc4'),
- ('\U00000cc7', '\U00000cc8'),
- ('\U00000cca', '\U00000ccb'),
- ('\U00000cd5', '\U00000cd6'),
- ('\U00000d02', '\U00000d03'),
- ('\U00000d3e', '\U00000d40'),
- ('\U00000d46', '\U00000d48'),
- ('\U00000d4a', '\U00000d4c'),
- ('\U00000d57', '\U00000d57'),
- ('\U00000d82', '\U00000d83'),
- ('\U00000dcf', '\U00000dd1'),
- ('\U00000dd8', '\U00000ddf'),
- ('\U00000df2', '\U00000df3'),
- ('\U00000f3e', '\U00000f3f'),
- ('\U00000f7f', '\U00000f7f'),
- ('\U0000102b', '\U0000102c'),
- ('\U00001031', '\U00001031'),
- ('\U00001038', '\U00001038'),
- ('\U0000103b', '\U0000103c'),
- ('\U00001056', '\U00001057'),
- ('\U00001062', '\U00001064'),
- ('\U00001067', '\U0000106d'),
- ('\U00001083', '\U00001084'),
- ('\U00001087', '\U0000108c'),
- ('\U0000108f', '\U0000108f'),
- ('\U0000109a', '\U0000109c'),
- ('\U000017b6', '\U000017b6'),
- ('\U000017be', '\U000017c5'),
- ('\U000017c7', '\U000017c8'),
- ('\U00001923', '\U00001926'),
- ('\U00001929', '\U0000192b'),
- ('\U00001930', '\U00001931'),
- ('\U00001933', '\U00001938'),
- ('\U000019b0', '\U000019c0'),
- ('\U000019c8', '\U000019c9'),
- ('\U00001a19', '\U00001a1a'),
- ('\U00001a55', '\U00001a55'),
- ('\U00001a57', '\U00001a57'),
- ('\U00001a61', '\U00001a61'),
- ('\U00001a63', '\U00001a64'),
- ('\U00001a6d', '\U00001a72'),
- ('\U00001b04', '\U00001b04'),
- ('\U00001b35', '\U00001b35'),
- ('\U00001b3b', '\U00001b3b'),
- ('\U00001b3d', '\U00001b41'),
- ('\U00001b43', '\U00001b44'),
- ('\U00001b82', '\U00001b82'),
- ('\U00001ba1', '\U00001ba1'),
- ('\U00001ba6', '\U00001ba7'),
- ('\U00001baa', '\U00001baa'),
- ('\U00001bac', '\U00001bad'),
- ('\U00001be7', '\U00001be7'),
- ('\U00001bea', '\U00001bec'),
- ('\U00001bee', '\U00001bee'),
- ('\U00001bf2', '\U00001bf3'),
- ('\U00001c24', '\U00001c2b'),
- ('\U00001c34', '\U00001c35'),
- ('\U00001ce1', '\U00001ce1'),
- ('\U00001cf2', '\U00001cf3'),
- ('\U0000302e', '\U0000302f'),
- ('\U0000a823', '\U0000a824'),
- ('\U0000a827', '\U0000a827'),
- ('\U0000a880', '\U0000a881'),
- ('\U0000a8b4', '\U0000a8c3'),
- ('\U0000a952', '\U0000a953'),
- ('\U0000a983', '\U0000a983'),
- ('\U0000a9b4', '\U0000a9b5'),
- ('\U0000a9ba', '\U0000a9bb'),
- ('\U0000a9bd', '\U0000a9c0'),
- ('\U0000aa2f', '\U0000aa30'),
- ('\U0000aa33', '\U0000aa34'),
- ('\U0000aa4d', '\U0000aa4d'),
- ('\U0000aa7b', '\U0000aa7b'),
- ('\U0000aaeb', '\U0000aaeb'),
- ('\U0000aaee', '\U0000aaef'),
- ('\U0000aaf5', '\U0000aaf5'),
- ('\U0000abe3', '\U0000abe4'),
- ('\U0000abe6', '\U0000abe7'),
- ('\U0000abe9', '\U0000abea'),
- ('\U0000abec', '\U0000abec'),
- ('\U00011000', '\U00011000'),
- ('\U00011002', '\U00011002'),
- ('\U00011082', '\U00011082'),
- ('\U000110b0', '\U000110b2'),
- ('\U000110b7', '\U000110b8'),
- ('\U0001112c', '\U0001112c'),
- ('\U00011182', '\U00011182'),
- ('\U000111b3', '\U000111b5'),
- ('\U000111bf', '\U000111c0'),
- ('\U000116ac', '\U000116ac'),
- ('\U000116ae', '\U000116af'),
- ('\U000116b6', '\U000116b6'),
- ('\U00016f51', '\U00016f7e'),
- ('\U0001d165', '\U0001d166'),
- ('\U0001d16d', '\U0001d172')
- ]),
-("Me", &[
- ('\U00000488', '\U00000489'),
- ('\U000020dd', '\U000020e0'),
- ('\U000020e2', '\U000020e4'),
- ('\U0000a670', '\U0000a672')
- ]),
-("Meetei_Mayek", &[
- ('\U0000aae0', '\U0000aaf6'),
- ('\U0000abc0', '\U0000abed'),
- ('\U0000abf0', '\U0000abf9')
- ]),
-("Meroitic_Cursive", &[
- ('\U000109a0', '\U000109b7'),
- ('\U000109be', '\U000109bf')
- ]),
-("Meroitic_Hieroglyphs", &[
- ('\U00010980', '\U0001099f')
- ]),
-("Miao", &[
- ('\U00016f00', '\U00016f44'),
- ('\U00016f50', '\U00016f7e'),
- ('\U00016f8f', '\U00016f9f')
- ]),
-("Mn", &[
- ('\U00000300', '\U0000036f'),
- ('\U00000483', '\U00000487'),
- ('\U00000591', '\U000005bd'),
- ('\U000005bf', '\U000005bf'),
- ('\U000005c1', '\U000005c2'),
- ('\U000005c4', '\U000005c5'),
- ('\U000005c7', '\U000005c7'),
- ('\U00000610', '\U0000061a'),
- ('\U0000064b', '\U0000065f'),
- ('\U00000670', '\U00000670'),
- ('\U000006d6', '\U000006dc'),
- ('\U000006df', '\U000006e4'),
- ('\U000006e7', '\U000006e8'),
- ('\U000006ea', '\U000006ed'),
- ('\U00000711', '\U00000711'),
- ('\U00000730', '\U0000074a'),
- ('\U000007a6', '\U000007b0'),
- ('\U000007eb', '\U000007f3'),
- ('\U00000816', '\U00000819'),
- ('\U0000081b', '\U00000823'),
- ('\U00000825', '\U00000827'),
- ('\U00000829', '\U0000082d'),
- ('\U00000859', '\U0000085b'),
- ('\U000008e4', '\U000008fe'),
- ('\U00000900', '\U00000902'),
- ('\U0000093a', '\U0000093a'),
- ('\U0000093c', '\U0000093c'),
- ('\U00000941', '\U00000948'),
- ('\U0000094d', '\U0000094d'),
- ('\U00000951', '\U00000957'),
- ('\U00000962', '\U00000963'),
- ('\U00000981', '\U00000981'),
- ('\U000009bc', '\U000009bc'),
- ('\U000009c1', '\U000009c4'),
- ('\U000009cd', '\U000009cd'),
- ('\U000009e2', '\U000009e3'),
- ('\U00000a01', '\U00000a02'),
- ('\U00000a3c', '\U00000a3c'),
- ('\U00000a41', '\U00000a42'),
- ('\U00000a47', '\U00000a48'),
- ('\U00000a4b', '\U00000a4d'),
- ('\U00000a51', '\U00000a51'),
- ('\U00000a70', '\U00000a71'),
- ('\U00000a75', '\U00000a75'),
- ('\U00000a81', '\U00000a82'),
- ('\U00000abc', '\U00000abc'),
- ('\U00000ac1', '\U00000ac5'),
- ('\U00000ac7', '\U00000ac8'),
- ('\U00000acd', '\U00000acd'),
- ('\U00000ae2', '\U00000ae3'),
- ('\U00000b01', '\U00000b01'),
- ('\U00000b3c', '\U00000b3c'),
- ('\U00000b3f', '\U00000b3f'),
- ('\U00000b41', '\U00000b44'),
- ('\U00000b4d', '\U00000b4d'),
- ('\U00000b56', '\U00000b56'),
- ('\U00000b62', '\U00000b63'),
- ('\U00000b82', '\U00000b82'),
- ('\U00000bc0', '\U00000bc0'),
- ('\U00000bcd', '\U00000bcd'),
- ('\U00000c3e', '\U00000c40'),
- ('\U00000c46', '\U00000c48'),
- ('\U00000c4a', '\U00000c4d'),
- ('\U00000c55', '\U00000c56'),
- ('\U00000c62', '\U00000c63'),
- ('\U00000cbc', '\U00000cbc'),
- ('\U00000cbf', '\U00000cbf'),
- ('\U00000cc6', '\U00000cc6'),
- ('\U00000ccc', '\U00000ccd'),
- ('\U00000ce2', '\U00000ce3'),
- ('\U00000d41', '\U00000d44'),
- ('\U00000d4d', '\U00000d4d'),
- ('\U00000d62', '\U00000d63'),
- ('\U00000dca', '\U00000dca'),
- ('\U00000dd2', '\U00000dd4'),
- ('\U00000dd6', '\U00000dd6'),
- ('\U00000e31', '\U00000e31'),
- ('\U00000e34', '\U00000e3a'),
- ('\U00000e47', '\U00000e4e'),
- ('\U00000eb1', '\U00000eb1'),
- ('\U00000eb4', '\U00000eb9'),
- ('\U00000ebb', '\U00000ebc'),
- ('\U00000ec8', '\U00000ecd'),
- ('\U00000f18', '\U00000f19'),
- ('\U00000f35', '\U00000f35'),
- ('\U00000f37', '\U00000f37'),
- ('\U00000f39', '\U00000f39'),
- ('\U00000f71', '\U00000f7e'),
- ('\U00000f80', '\U00000f84'),
- ('\U00000f86', '\U00000f87'),
- ('\U00000f8d', '\U00000f97'),
- ('\U00000f99', '\U00000fbc'),
- ('\U00000fc6', '\U00000fc6'),
- ('\U0000102d', '\U00001030'),
- ('\U00001032', '\U00001037'),
- ('\U00001039', '\U0000103a'),
- ('\U0000103d', '\U0000103e'),
- ('\U00001058', '\U00001059'),
- ('\U0000105e', '\U00001060'),
- ('\U00001071', '\U00001074'),
- ('\U00001082', '\U00001082'),
- ('\U00001085', '\U00001086'),
- ('\U0000108d', '\U0000108d'),
- ('\U0000109d', '\U0000109d'),
- ('\U0000135d', '\U0000135f'),
- ('\U00001712', '\U00001714'),
- ('\U00001732', '\U00001734'),
- ('\U00001752', '\U00001753'),
- ('\U00001772', '\U00001773'),
- ('\U000017b4', '\U000017b5'),
- ('\U000017b7', '\U000017bd'),
- ('\U000017c6', '\U000017c6'),
- ('\U000017c9', '\U000017d3'),
- ('\U000017dd', '\U000017dd'),
- ('\U0000180b', '\U0000180d'),
- ('\U000018a9', '\U000018a9'),
- ('\U00001920', '\U00001922'),
- ('\U00001927', '\U00001928'),
- ('\U00001932', '\U00001932'),
- ('\U00001939', '\U0000193b'),
- ('\U00001a17', '\U00001a18'),
- ('\U00001a1b', '\U00001a1b'),
- ('\U00001a56', '\U00001a56'),
- ('\U00001a58', '\U00001a5e'),
- ('\U00001a60', '\U00001a60'),
- ('\U00001a62', '\U00001a62'),
- ('\U00001a65', '\U00001a6c'),
- ('\U00001a73', '\U00001a7c'),
- ('\U00001a7f', '\U00001a7f'),
- ('\U00001b00', '\U00001b03'),
- ('\U00001b34', '\U00001b34'),
- ('\U00001b36', '\U00001b3a'),
- ('\U00001b3c', '\U00001b3c'),
- ('\U00001b42', '\U00001b42'),
- ('\U00001b6b', '\U00001b73'),
- ('\U00001b80', '\U00001b81'),
- ('\U00001ba2', '\U00001ba5'),
- ('\U00001ba8', '\U00001ba9'),
- ('\U00001bab', '\U00001bab'),
- ('\U00001be6', '\U00001be6'),
- ('\U00001be8', '\U00001be9'),
- ('\U00001bed', '\U00001bed'),
- ('\U00001bef', '\U00001bf1'),
- ('\U00001c2c', '\U00001c33'),
- ('\U00001c36', '\U00001c37'),
- ('\U00001cd0', '\U00001cd2'),
- ('\U00001cd4', '\U00001ce0'),
- ('\U00001ce2', '\U00001ce8'),
- ('\U00001ced', '\U00001ced'),
- ('\U00001cf4', '\U00001cf4'),
- ('\U00001dc0', '\U00001de6'),
- ('\U00001dfc', '\U00001dff'),
- ('\U000020d0', '\U000020dc'),
- ('\U000020e1', '\U000020e1'),
- ('\U000020e5', '\U000020f0'),
- ('\U00002cef', '\U00002cf1'),
- ('\U00002d7f', '\U00002d7f'),
- ('\U00002de0', '\U00002dff'),
- ('\U0000302a', '\U0000302d'),
- ('\U00003099', '\U0000309a'),
- ('\U0000a66f', '\U0000a66f'),
- ('\U0000a674', '\U0000a67d'),
- ('\U0000a69f', '\U0000a69f'),
- ('\U0000a6f0', '\U0000a6f1'),
- ('\U0000a802', '\U0000a802'),
- ('\U0000a806', '\U0000a806'),
- ('\U0000a80b', '\U0000a80b'),
- ('\U0000a825', '\U0000a826'),
- ('\U0000a8c4', '\U0000a8c4'),
- ('\U0000a8e0', '\U0000a8f1'),
- ('\U0000a926', '\U0000a92d'),
- ('\U0000a947', '\U0000a951'),
- ('\U0000a980', '\U0000a982'),
- ('\U0000a9b3', '\U0000a9b3'),
- ('\U0000a9b6', '\U0000a9b9'),
- ('\U0000a9bc', '\U0000a9bc'),
- ('\U0000aa29', '\U0000aa2e'),
- ('\U0000aa31', '\U0000aa32'),
- ('\U0000aa35', '\U0000aa36'),
- ('\U0000aa43', '\U0000aa43'),
- ('\U0000aa4c', '\U0000aa4c'),
- ('\U0000aab0', '\U0000aab0'),
- ('\U0000aab2', '\U0000aab4'),
- ('\U0000aab7', '\U0000aab8'),
- ('\U0000aabe', '\U0000aabf'),
- ('\U0000aac1', '\U0000aac1'),
- ('\U0000aaec', '\U0000aaed'),
- ('\U0000aaf6', '\U0000aaf6'),
- ('\U0000abe5', '\U0000abe5'),
- ('\U0000abe8', '\U0000abe8'),
- ('\U0000abed', '\U0000abed'),
- ('\U0000fb1e', '\U0000fb1e'),
- ('\U0000fe00', '\U0000fe0f'),
- ('\U0000fe20', '\U0000fe26'),
- ('\U000101fd', '\U000101fd'),
- ('\U00010a01', '\U00010a03'),
- ('\U00010a05', '\U00010a06'),
- ('\U00010a0c', '\U00010a0f'),
- ('\U00010a38', '\U00010a3a'),
- ('\U00010a3f', '\U00010a3f'),
- ('\U00011001', '\U00011001'),
- ('\U00011038', '\U00011046'),
- ('\U00011080', '\U00011081'),
- ('\U000110b3', '\U000110b6'),
- ('\U000110b9', '\U000110ba'),
- ('\U00011100', '\U00011102'),
- ('\U00011127', '\U0001112b'),
- ('\U0001112d', '\U00011134'),
- ('\U00011180', '\U00011181'),
- ('\U000111b6', '\U000111be'),
- ('\U000116ab', '\U000116ab'),
- ('\U000116ad', '\U000116ad'),
- ('\U000116b0', '\U000116b5'),
- ('\U000116b7', '\U000116b7'),
- ('\U00016f8f', '\U00016f92'),
- ('\U0001d167', '\U0001d169'),
- ('\U0001d17b', '\U0001d182'),
- ('\U0001d185', '\U0001d18b'),
- ('\U0001d1aa', '\U0001d1ad'),
- ('\U0001d242', '\U0001d244'),
- ('\U000e0100', '\U000e01ef')
- ]),
-("Mongolian", &[
- ('\U00001800', '\U00001801'),
- ('\U00001804', '\U00001804'),
- ('\U00001806', '\U0000180e'),
- ('\U00001810', '\U00001819'),
- ('\U00001820', '\U00001877'),
- ('\U00001880', '\U000018aa')
- ]),
-("Myanmar", &[
- ('\U00001000', '\U0000109f'),
- ('\U0000aa60', '\U0000aa7b')
- ]),
-("N", &[
- ('\U00000030', '\U00000039'),
- ('\U00000660', '\U00000669'),
- ('\U000006f0', '\U000006f9'),
- ('\U000007c0', '\U000007c9'),
- ('\U00000966', '\U0000096f'),
- ('\U000009e6', '\U000009ef'),
- ('\U00000a66', '\U00000a6f'),
- ('\U00000ae6', '\U00000aef'),
- ('\U00000b66', '\U00000b6f'),
- ('\U00000be6', '\U00000bef'),
- ('\U00000c66', '\U00000c6f'),
- ('\U00000ce6', '\U00000cef'),
- ('\U00000d66', '\U00000d6f'),
- ('\U00000e50', '\U00000e59'),
- ('\U00000ed0', '\U00000ed9'),
- ('\U00000f20', '\U00000f29'),
- ('\U00001040', '\U00001049'),
- ('\U00001090', '\U00001099'),
- ('\U000016ee', '\U000016f0'),
- ('\U000017e0', '\U000017e9'),
- ('\U00001810', '\U00001819'),
- ('\U00001946', '\U0000194f'),
- ('\U000019d0', '\U000019d9'),
- ('\U00001a80', '\U00001a89'),
- ('\U00001a90', '\U00001a99'),
- ('\U00001b50', '\U00001b59'),
- ('\U00001bb0', '\U00001bb9'),
- ('\U00001c40', '\U00001c49'),
- ('\U00001c50', '\U00001c59'),
- ('\U00002160', '\U00002182'),
- ('\U00002185', '\U00002188'),
- ('\U00003007', '\U00003007'),
- ('\U00003021', '\U00003029'),
- ('\U00003038', '\U0000303a'),
- ('\U0000a620', '\U0000a629'),
- ('\U0000a6e6', '\U0000a6ef'),
- ('\U0000a8d0', '\U0000a8d9'),
- ('\U0000a900', '\U0000a909'),
- ('\U0000a9d0', '\U0000a9d9'),
- ('\U0000aa50', '\U0000aa59'),
- ('\U0000abf0', '\U0000abf9'),
- ('\U0000ff10', '\U0000ff19'),
- ('\U00010140', '\U00010174'),
- ('\U00010341', '\U00010341'),
- ('\U0001034a', '\U0001034a'),
- ('\U000103d1', '\U000103d5'),
- ('\U000104a0', '\U000104a9'),
- ('\U00011066', '\U0001106f'),
- ('\U000110f0', '\U000110f9'),
- ('\U00011136', '\U0001113f'),
- ('\U000111d0', '\U000111d9'),
- ('\U000116c0', '\U000116c9'),
- ('\U00012400', '\U00012462'),
- ('\U0001d7ce', '\U0001d7ff')
- ]),
-("Nd", &[
- ('\U00000030', '\U00000039'),
- ('\U00000660', '\U00000669'),
- ('\U000006f0', '\U000006f9'),
- ('\U000007c0', '\U000007c9'),
- ('\U00000966', '\U0000096f'),
- ('\U000009e6', '\U000009ef'),
- ('\U00000a66', '\U00000a6f'),
- ('\U00000ae6', '\U00000aef'),
- ('\U00000b66', '\U00000b6f'),
- ('\U00000be6', '\U00000bef'),
- ('\U00000c66', '\U00000c6f'),
- ('\U00000ce6', '\U00000cef'),
- ('\U00000d66', '\U00000d6f'),
- ('\U00000e50', '\U00000e59'),
- ('\U00000ed0', '\U00000ed9'),
- ('\U00000f20', '\U00000f29'),
- ('\U00001040', '\U00001049'),
- ('\U00001090', '\U00001099'),
- ('\U000017e0', '\U000017e9'),
- ('\U00001810', '\U00001819'),
- ('\U00001946', '\U0000194f'),
- ('\U000019d0', '\U000019d9'),
- ('\U00001a80', '\U00001a89'),
- ('\U00001a90', '\U00001a99'),
- ('\U00001b50', '\U00001b59'),
- ('\U00001bb0', '\U00001bb9'),
- ('\U00001c40', '\U00001c49'),
- ('\U00001c50', '\U00001c59'),
- ('\U0000a620', '\U0000a629'),
- ('\U0000a8d0', '\U0000a8d9'),
- ('\U0000a900', '\U0000a909'),
- ('\U0000a9d0', '\U0000a9d9'),
- ('\U0000aa50', '\U0000aa59'),
- ('\U0000abf0', '\U0000abf9'),
- ('\U0000ff10', '\U0000ff19'),
- ('\U000104a0', '\U000104a9'),
- ('\U00011066', '\U0001106f'),
- ('\U000110f0', '\U000110f9'),
- ('\U00011136', '\U0001113f'),
- ('\U000111d0', '\U000111d9'),
- ('\U000116c0', '\U000116c9'),
- ('\U0001d7ce', '\U0001d7ff')
- ]),
-("New_Tai_Lue", &[
- ('\U00001980', '\U000019ab'),
- ('\U000019b0', '\U000019c9'),
- ('\U000019d0', '\U000019da'),
- ('\U000019de', '\U000019df')
- ]),
-("Nko", &[
- ('\U000007c0', '\U000007fa')
- ]),
-("Nl", &[
- ('\U000016ee', '\U000016f0'),
- ('\U00002160', '\U00002182'),
- ('\U00002185', '\U00002188'),
- ('\U00003007', '\U00003007'),
- ('\U00003021', '\U00003029'),
- ('\U00003038', '\U0000303a'),
- ('\U0000a6e6', '\U0000a6ef'),
- ('\U00010140', '\U00010174'),
- ('\U00010341', '\U00010341'),
- ('\U0001034a', '\U0001034a'),
- ('\U000103d1', '\U000103d5'),
- ('\U00012400', '\U00012462')
- ]),
-("No", &[
- ('\U000000b2', '\U000000b3'),
- ('\U000000b9', '\U000000b9'),
- ('\U000000bc', '\U000000be'),
- ('\U000009f4', '\U000009f9'),
- ('\U00000b72', '\U00000b77'),
- ('\U00000bf0', '\U00000bf2'),
- ('\U00000c78', '\U00000c7e'),
- ('\U00000d70', '\U00000d75'),
- ('\U00000f2a', '\U00000f33'),
- ('\U00001369', '\U0000137c'),
- ('\U000017f0', '\U000017f9'),
- ('\U000019da', '\U000019da'),
- ('\U00002070', '\U00002070'),
- ('\U00002074', '\U00002079'),
- ('\U00002080', '\U00002089'),
- ('\U00002150', '\U0000215f'),
- ('\U00002189', '\U00002189'),
- ('\U00002460', '\U0000249b'),
- ('\U000024ea', '\U000024ff'),
- ('\U00002776', '\U00002793'),
- ('\U00002cfd', '\U00002cfd'),
- ('\U00003192', '\U00003195'),
- ('\U00003220', '\U00003229'),
- ('\U00003248', '\U0000324f'),
- ('\U00003251', '\U0000325f'),
- ('\U00003280', '\U00003289'),
- ('\U000032b1', '\U000032bf'),
- ('\U0000a830', '\U0000a835'),
- ('\U00010107', '\U00010133'),
- ('\U00010175', '\U00010178'),
- ('\U0001018a', '\U0001018a'),
- ('\U00010320', '\U00010323'),
- ('\U00010858', '\U0001085f'),
- ('\U00010916', '\U0001091b'),
- ('\U00010a40', '\U00010a47'),
- ('\U00010a7d', '\U00010a7e'),
- ('\U00010b58', '\U00010b5f'),
- ('\U00010b78', '\U00010b7f'),
- ('\U00010e60', '\U00010e7e'),
- ('\U00011052', '\U00011065'),
- ('\U0001d360', '\U0001d371'),
- ('\U0001f100', '\U0001f10a')
- ]),
-("Ogham", &[
- ('\U00001680', '\U0000169c')
- ]),
-("Ol_Chiki", &[
- ('\U00001c50', '\U00001c7f')
- ]),
-("Old_Italic", &[
- ('\U00010300', '\U0001031e'),
- ('\U00010320', '\U00010323')
- ]),
-("Old_Persian", &[
- ('\U000103a0', '\U000103c3'),
- ('\U000103c8', '\U000103d5')
- ]),
-("Old_South_Arabian", &[
- ('\U00010a60', '\U00010a7f')
- ]),
-("Old_Turkic", &[
- ('\U00010c00', '\U00010c48')
- ]),
-("Oriya", &[
- ('\U00000b01', '\U00000b03'),
- ('\U00000b05', '\U00000b0c'),
- ('\U00000b0f', '\U00000b10'),
- ('\U00000b13', '\U00000b28'),
- ('\U00000b2a', '\U00000b30'),
- ('\U00000b32', '\U00000b33'),
- ('\U00000b35', '\U00000b39'),
- ('\U00000b3c', '\U00000b44'),
- ('\U00000b47', '\U00000b48'),
- ('\U00000b4b', '\U00000b4d'),
- ('\U00000b56', '\U00000b57'),
- ('\U00000b5c', '\U00000b5d'),
- ('\U00000b5f', '\U00000b63'),
- ('\U00000b66', '\U00000b77')
- ]),
-("Osmanya", &[
- ('\U00010480', '\U0001049d'),
- ('\U000104a0', '\U000104a9')
- ]),
-("P", &[
- ('\U00000021', '\U00000023'),
- ('\U00000025', '\U0000002a'),
- ('\U0000002c', '\U0000002f'),
- ('\U0000003a', '\U0000003b'),
- ('\U0000003f', '\U00000040'),
- ('\U0000005b', '\U0000005d'),
- ('\U0000005f', '\U0000005f'),
- ('\U0000007b', '\U0000007b'),
- ('\U0000007d', '\U0000007d'),
- ('\U000000a1', '\U000000a1'),
- ('\U000000a7', '\U000000a7'),
- ('\U000000ab', '\U000000ab'),
- ('\U000000b6', '\U000000b7'),
- ('\U000000bb', '\U000000bb'),
- ('\U000000bf', '\U000000bf'),
- ('\U0000037e', '\U0000037e'),
- ('\U00000387', '\U00000387'),
- ('\U0000055a', '\U0000055f'),
- ('\U00000589', '\U0000058a'),
- ('\U000005be', '\U000005be'),
- ('\U000005c0', '\U000005c0'),
- ('\U000005c3', '\U000005c3'),
- ('\U000005c6', '\U000005c6'),
- ('\U000005f3', '\U000005f4'),
- ('\U00000609', '\U0000060a'),
- ('\U0000060c', '\U0000060d'),
- ('\U0000061b', '\U0000061b'),
- ('\U0000061e', '\U0000061f'),
- ('\U0000066a', '\U0000066d'),
- ('\U000006d4', '\U000006d4'),
- ('\U00000700', '\U0000070d'),
- ('\U000007f7', '\U000007f9'),
- ('\U00000830', '\U0000083e'),
- ('\U0000085e', '\U0000085e'),
- ('\U00000964', '\U00000965'),
- ('\U00000970', '\U00000970'),
- ('\U00000af0', '\U00000af0'),
- ('\U00000df4', '\U00000df4'),
- ('\U00000e4f', '\U00000e4f'),
- ('\U00000e5a', '\U00000e5b'),
- ('\U00000f04', '\U00000f12'),
- ('\U00000f14', '\U00000f14'),
- ('\U00000f3a', '\U00000f3d'),
- ('\U00000f85', '\U00000f85'),
- ('\U00000fd0', '\U00000fd4'),
- ('\U00000fd9', '\U00000fda'),
- ('\U0000104a', '\U0000104f'),
- ('\U000010fb', '\U000010fb'),
- ('\U00001360', '\U00001368'),
- ('\U00001400', '\U00001400'),
- ('\U0000166d', '\U0000166e'),
- ('\U0000169b', '\U0000169c'),
- ('\U000016eb', '\U000016ed'),
- ('\U00001735', '\U00001736'),
- ('\U000017d4', '\U000017d6'),
- ('\U000017d8', '\U000017da'),
- ('\U00001800', '\U0000180a'),
- ('\U00001944', '\U00001945'),
- ('\U00001a1e', '\U00001a1f'),
- ('\U00001aa0', '\U00001aa6'),
- ('\U00001aa8', '\U00001aad'),
- ('\U00001b5a', '\U00001b60'),
- ('\U00001bfc', '\U00001bff'),
- ('\U00001c3b', '\U00001c3f'),
- ('\U00001c7e', '\U00001c7f'),
- ('\U00001cc0', '\U00001cc7'),
- ('\U00001cd3', '\U00001cd3'),
- ('\U00002010', '\U00002027'),
- ('\U00002030', '\U00002043'),
- ('\U00002045', '\U00002051'),
- ('\U00002053', '\U0000205e'),
- ('\U0000207d', '\U0000207e'),
- ('\U0000208d', '\U0000208e'),
- ('\U00002308', '\U0000230b'),
- ('\U00002329', '\U0000232a'),
- ('\U00002768', '\U00002775'),
- ('\U000027c5', '\U000027c6'),
- ('\U000027e6', '\U000027ef'),
- ('\U00002983', '\U00002998'),
- ('\U000029d8', '\U000029db'),
- ('\U000029fc', '\U000029fd'),
- ('\U00002cf9', '\U00002cfc'),
- ('\U00002cfe', '\U00002cff'),
- ('\U00002d70', '\U00002d70'),
- ('\U00002e00', '\U00002e2e'),
- ('\U00002e30', '\U00002e3b'),
- ('\U00003001', '\U00003003'),
- ('\U00003008', '\U00003011'),
- ('\U00003014', '\U0000301f'),
- ('\U00003030', '\U00003030'),
- ('\U0000303d', '\U0000303d'),
- ('\U000030a0', '\U000030a0'),
- ('\U000030fb', '\U000030fb'),
- ('\U0000a4fe', '\U0000a4ff'),
- ('\U0000a60d', '\U0000a60f'),
- ('\U0000a673', '\U0000a673'),
- ('\U0000a67e', '\U0000a67e'),
- ('\U0000a6f2', '\U0000a6f7'),
- ('\U0000a874', '\U0000a877'),
- ('\U0000a8ce', '\U0000a8cf'),
- ('\U0000a8f8', '\U0000a8fa'),
- ('\U0000a92e', '\U0000a92f'),
- ('\U0000a95f', '\U0000a95f'),
- ('\U0000a9c1', '\U0000a9cd'),
- ('\U0000a9de', '\U0000a9df'),
- ('\U0000aa5c', '\U0000aa5f'),
- ('\U0000aade', '\U0000aadf'),
- ('\U0000aaf0', '\U0000aaf1'),
- ('\U0000abeb', '\U0000abeb'),
- ('\U0000fd3e', '\U0000fd3f'),
- ('\U0000fe10', '\U0000fe19'),
- ('\U0000fe30', '\U0000fe52'),
- ('\U0000fe54', '\U0000fe61'),
- ('\U0000fe63', '\U0000fe63'),
- ('\U0000fe68', '\U0000fe68'),
- ('\U0000fe6a', '\U0000fe6b'),
- ('\U0000ff01', '\U0000ff03'),
- ('\U0000ff05', '\U0000ff0a'),
- ('\U0000ff0c', '\U0000ff0f'),
- ('\U0000ff1a', '\U0000ff1b'),
- ('\U0000ff1f', '\U0000ff20'),
- ('\U0000ff3b', '\U0000ff3d'),
- ('\U0000ff3f', '\U0000ff3f'),
- ('\U0000ff5b', '\U0000ff5b'),
- ('\U0000ff5d', '\U0000ff5d'),
- ('\U0000ff5f', '\U0000ff65'),
- ('\U00010100', '\U00010102'),
- ('\U0001039f', '\U0001039f'),
- ('\U000103d0', '\U000103d0'),
- ('\U00010857', '\U00010857'),
- ('\U0001091f', '\U0001091f'),
- ('\U0001093f', '\U0001093f'),
- ('\U00010a50', '\U00010a58'),
- ('\U00010a7f', '\U00010a7f'),
- ('\U00010b39', '\U00010b3f'),
- ('\U00011047', '\U0001104d'),
- ('\U000110bb', '\U000110bc'),
- ('\U000110be', '\U000110c1'),
- ('\U00011140', '\U00011143'),
- ('\U000111c5', '\U000111c8'),
- ('\U00012470', '\U00012473')
- ]),
-("Pc", &[
- ('\U0000005f', '\U0000005f'),
- ('\U0000203f', '\U00002040'),
- ('\U00002054', '\U00002054'),
- ('\U0000fe33', '\U0000fe34'),
- ('\U0000fe4d', '\U0000fe4f'),
- ('\U0000ff3f', '\U0000ff3f')
- ]),
-("Pd", &[
- ('\U0000002d', '\U0000002d'),
- ('\U0000058a', '\U0000058a'),
- ('\U000005be', '\U000005be'),
- ('\U00001400', '\U00001400'),
- ('\U00001806', '\U00001806'),
- ('\U00002010', '\U00002015'),
- ('\U00002e17', '\U00002e17'),
- ('\U00002e1a', '\U00002e1a'),
- ('\U00002e3a', '\U00002e3b'),
- ('\U0000301c', '\U0000301c'),
- ('\U00003030', '\U00003030'),
- ('\U000030a0', '\U000030a0'),
- ('\U0000fe31', '\U0000fe32'),
- ('\U0000fe58', '\U0000fe58'),
- ('\U0000fe63', '\U0000fe63'),
- ('\U0000ff0d', '\U0000ff0d')
- ]),
-("Pe", &[
- ('\U00000029', '\U00000029'),
- ('\U0000005d', '\U0000005d'),
- ('\U0000007d', '\U0000007d'),
- ('\U00000f3b', '\U00000f3b'),
- ('\U00000f3d', '\U00000f3d'),
- ('\U0000169c', '\U0000169c'),
- ('\U00002046', '\U00002046'),
- ('\U0000207e', '\U0000207e'),
- ('\U0000208e', '\U0000208e'),
- ('\U00002309', '\U00002309'),
- ('\U0000230b', '\U0000230b'),
- ('\U0000232a', '\U0000232a'),
- ('\U00002769', '\U00002769'),
- ('\U0000276b', '\U0000276b'),
- ('\U0000276d', '\U0000276d'),
- ('\U0000276f', '\U0000276f'),
- ('\U00002771', '\U00002771'),
- ('\U00002773', '\U00002773'),
- ('\U00002775', '\U00002775'),
- ('\U000027c6', '\U000027c6'),
- ('\U000027e7', '\U000027e7'),
- ('\U000027e9', '\U000027e9'),
- ('\U000027eb', '\U000027eb'),
- ('\U000027ed', '\U000027ed'),
- ('\U000027ef', '\U000027ef'),
- ('\U00002984', '\U00002984'),
- ('\U00002986', '\U00002986'),
- ('\U00002988', '\U00002988'),
- ('\U0000298a', '\U0000298a'),
- ('\U0000298c', '\U0000298c'),
- ('\U0000298e', '\U0000298e'),
- ('\U00002990', '\U00002990'),
- ('\U00002992', '\U00002992'),
- ('\U00002994', '\U00002994'),
- ('\U00002996', '\U00002996'),
- ('\U00002998', '\U00002998'),
- ('\U000029d9', '\U000029d9'),
- ('\U000029db', '\U000029db'),
- ('\U000029fd', '\U000029fd'),
- ('\U00002e23', '\U00002e23'),
- ('\U00002e25', '\U00002e25'),
- ('\U00002e27', '\U00002e27'),
- ('\U00002e29', '\U00002e29'),
- ('\U00003009', '\U00003009'),
- ('\U0000300b', '\U0000300b'),
- ('\U0000300d', '\U0000300d'),
- ('\U0000300f', '\U0000300f'),
- ('\U00003011', '\U00003011'),
- ('\U00003015', '\U00003015'),
- ('\U00003017', '\U00003017'),
- ('\U00003019', '\U00003019'),
- ('\U0000301b', '\U0000301b'),
- ('\U0000301e', '\U0000301f'),
- ('\U0000fd3f', '\U0000fd3f'),
- ('\U0000fe18', '\U0000fe18'),
- ('\U0000fe36', '\U0000fe36'),
- ('\U0000fe38', '\U0000fe38'),
- ('\U0000fe3a', '\U0000fe3a'),
- ('\U0000fe3c', '\U0000fe3c'),
- ('\U0000fe3e', '\U0000fe3e'),
- ('\U0000fe40', '\U0000fe40'),
- ('\U0000fe42', '\U0000fe42'),
- ('\U0000fe44', '\U0000fe44'),
- ('\U0000fe48', '\U0000fe48'),
- ('\U0000fe5a', '\U0000fe5a'),
- ('\U0000fe5c', '\U0000fe5c'),
- ('\U0000fe5e', '\U0000fe5e'),
- ('\U0000ff09', '\U0000ff09'),
- ('\U0000ff3d', '\U0000ff3d'),
- ('\U0000ff5d', '\U0000ff5d'),
- ('\U0000ff60', '\U0000ff60'),
- ('\U0000ff63', '\U0000ff63')
- ]),
-("Pf", &[
- ('\U000000bb', '\U000000bb'),
- ('\U00002019', '\U00002019'),
- ('\U0000201d', '\U0000201d'),
- ('\U0000203a', '\U0000203a'),
- ('\U00002e03', '\U00002e03'),
- ('\U00002e05', '\U00002e05'),
- ('\U00002e0a', '\U00002e0a'),
- ('\U00002e0d', '\U00002e0d'),
- ('\U00002e1d', '\U00002e1d'),
- ('\U00002e21', '\U00002e21')
- ]),
-("Phags_Pa", &[
- ('\U0000a840', '\U0000a877')
- ]),
-("Phoenician", &[
- ('\U00010900', '\U0001091b'),
- ('\U0001091f', '\U0001091f')
- ]),
-("Pi", &[
- ('\U000000ab', '\U000000ab'),
- ('\U00002018', '\U00002018'),
- ('\U0000201b', '\U0000201c'),
- ('\U0000201f', '\U0000201f'),
- ('\U00002039', '\U00002039'),
- ('\U00002e02', '\U00002e02'),
- ('\U00002e04', '\U00002e04'),
- ('\U00002e09', '\U00002e09'),
- ('\U00002e0c', '\U00002e0c'),
- ('\U00002e1c', '\U00002e1c'),
- ('\U00002e20', '\U00002e20')
- ]),
-("Po", &[
- ('\U00000021', '\U00000023'),
- ('\U00000025', '\U00000027'),
- ('\U0000002a', '\U0000002a'),
- ('\U0000002c', '\U0000002c'),
- ('\U0000002e', '\U0000002f'),
- ('\U0000003a', '\U0000003b'),
- ('\U0000003f', '\U00000040'),
- ('\U0000005c', '\U0000005c'),
- ('\U000000a1', '\U000000a1'),
- ('\U000000a7', '\U000000a7'),
- ('\U000000b6', '\U000000b7'),
- ('\U000000bf', '\U000000bf'),
- ('\U0000037e', '\U0000037e'),
- ('\U00000387', '\U00000387'),
- ('\U0000055a', '\U0000055f'),
- ('\U00000589', '\U00000589'),
- ('\U000005c0', '\U000005c0'),
- ('\U000005c3', '\U000005c3'),
- ('\U000005c6', '\U000005c6'),
- ('\U000005f3', '\U000005f4'),
- ('\U00000609', '\U0000060a'),
- ('\U0000060c', '\U0000060d'),
- ('\U0000061b', '\U0000061b'),
- ('\U0000061e', '\U0000061f'),
- ('\U0000066a', '\U0000066d'),
- ('\U000006d4', '\U000006d4'),
- ('\U00000700', '\U0000070d'),
- ('\U000007f7', '\U000007f9'),
- ('\U00000830', '\U0000083e'),
- ('\U0000085e', '\U0000085e'),
- ('\U00000964', '\U00000965'),
- ('\U00000970', '\U00000970'),
- ('\U00000af0', '\U00000af0'),
- ('\U00000df4', '\U00000df4'),
- ('\U00000e4f', '\U00000e4f'),
- ('\U00000e5a', '\U00000e5b'),
- ('\U00000f04', '\U00000f12'),
- ('\U00000f14', '\U00000f14'),
- ('\U00000f85', '\U00000f85'),
- ('\U00000fd0', '\U00000fd4'),
- ('\U00000fd9', '\U00000fda'),
- ('\U0000104a', '\U0000104f'),
- ('\U000010fb', '\U000010fb'),
- ('\U00001360', '\U00001368'),
- ('\U0000166d', '\U0000166e'),
- ('\U000016eb', '\U000016ed'),
- ('\U00001735', '\U00001736'),
- ('\U000017d4', '\U000017d6'),
- ('\U000017d8', '\U000017da'),
- ('\U00001800', '\U00001805'),
- ('\U00001807', '\U0000180a'),
- ('\U00001944', '\U00001945'),
- ('\U00001a1e', '\U00001a1f'),
- ('\U00001aa0', '\U00001aa6'),
- ('\U00001aa8', '\U00001aad'),
- ('\U00001b5a', '\U00001b60'),
- ('\U00001bfc', '\U00001bff'),
- ('\U00001c3b', '\U00001c3f'),
- ('\U00001c7e', '\U00001c7f'),
- ('\U00001cc0', '\U00001cc7'),
- ('\U00001cd3', '\U00001cd3'),
- ('\U00002016', '\U00002017'),
- ('\U00002020', '\U00002027'),
- ('\U00002030', '\U00002038'),
- ('\U0000203b', '\U0000203e'),
- ('\U00002041', '\U00002043'),
- ('\U00002047', '\U00002051'),
- ('\U00002053', '\U00002053'),
- ('\U00002055', '\U0000205e'),
- ('\U00002cf9', '\U00002cfc'),
- ('\U00002cfe', '\U00002cff'),
- ('\U00002d70', '\U00002d70'),
- ('\U00002e00', '\U00002e01'),
- ('\U00002e06', '\U00002e08'),
- ('\U00002e0b', '\U00002e0b'),
- ('\U00002e0e', '\U00002e16'),
- ('\U00002e18', '\U00002e19'),
- ('\U00002e1b', '\U00002e1b'),
- ('\U00002e1e', '\U00002e1f'),
- ('\U00002e2a', '\U00002e2e'),
- ('\U00002e30', '\U00002e39'),
- ('\U00003001', '\U00003003'),
- ('\U0000303d', '\U0000303d'),
- ('\U000030fb', '\U000030fb'),
- ('\U0000a4fe', '\U0000a4ff'),
- ('\U0000a60d', '\U0000a60f'),
- ('\U0000a673', '\U0000a673'),
- ('\U0000a67e', '\U0000a67e'),
- ('\U0000a6f2', '\U0000a6f7'),
- ('\U0000a874', '\U0000a877'),
- ('\U0000a8ce', '\U0000a8cf'),
- ('\U0000a8f8', '\U0000a8fa'),
- ('\U0000a92e', '\U0000a92f'),
- ('\U0000a95f', '\U0000a95f'),
- ('\U0000a9c1', '\U0000a9cd'),
- ('\U0000a9de', '\U0000a9df'),
- ('\U0000aa5c', '\U0000aa5f'),
- ('\U0000aade', '\U0000aadf'),
- ('\U0000aaf0', '\U0000aaf1'),
- ('\U0000abeb', '\U0000abeb'),
- ('\U0000fe10', '\U0000fe16'),
- ('\U0000fe19', '\U0000fe19'),
- ('\U0000fe30', '\U0000fe30'),
- ('\U0000fe45', '\U0000fe46'),
- ('\U0000fe49', '\U0000fe4c'),
- ('\U0000fe50', '\U0000fe52'),
- ('\U0000fe54', '\U0000fe57'),
- ('\U0000fe5f', '\U0000fe61'),
- ('\U0000fe68', '\U0000fe68'),
- ('\U0000fe6a', '\U0000fe6b'),
- ('\U0000ff01', '\U0000ff03'),
- ('\U0000ff05', '\U0000ff07'),
- ('\U0000ff0a', '\U0000ff0a'),
- ('\U0000ff0c', '\U0000ff0c'),
- ('\U0000ff0e', '\U0000ff0f'),
- ('\U0000ff1a', '\U0000ff1b'),
- ('\U0000ff1f', '\U0000ff20'),
- ('\U0000ff3c', '\U0000ff3c'),
- ('\U0000ff61', '\U0000ff61'),
- ('\U0000ff64', '\U0000ff65'),
- ('\U00010100', '\U00010102'),
- ('\U0001039f', '\U0001039f'),
- ('\U000103d0', '\U000103d0'),
- ('\U00010857', '\U00010857'),
- ('\U0001091f', '\U0001091f'),
- ('\U0001093f', '\U0001093f'),
- ('\U00010a50', '\U00010a58'),
- ('\U00010a7f', '\U00010a7f'),
- ('\U00010b39', '\U00010b3f'),
- ('\U00011047', '\U0001104d'),
- ('\U000110bb', '\U000110bc'),
- ('\U000110be', '\U000110c1'),
- ('\U00011140', '\U00011143'),
- ('\U000111c5', '\U000111c8'),
- ('\U00012470', '\U00012473')
- ]),
-("Ps", &[
- ('\U00000028', '\U00000028'),
- ('\U0000005b', '\U0000005b'),
- ('\U0000007b', '\U0000007b'),
- ('\U00000f3a', '\U00000f3a'),
- ('\U00000f3c', '\U00000f3c'),
- ('\U0000169b', '\U0000169b'),
- ('\U0000201a', '\U0000201a'),
- ('\U0000201e', '\U0000201e'),
- ('\U00002045', '\U00002045'),
- ('\U0000207d', '\U0000207d'),
- ('\U0000208d', '\U0000208d'),
- ('\U00002308', '\U00002308'),
- ('\U0000230a', '\U0000230a'),
- ('\U00002329', '\U00002329'),
- ('\U00002768', '\U00002768'),
- ('\U0000276a', '\U0000276a'),
- ('\U0000276c', '\U0000276c'),
- ('\U0000276e', '\U0000276e'),
- ('\U00002770', '\U00002770'),
- ('\U00002772', '\U00002772'),
- ('\U00002774', '\U00002774'),
- ('\U000027c5', '\U000027c5'),
- ('\U000027e6', '\U000027e6'),
- ('\U000027e8', '\U000027e8'),
- ('\U000027ea', '\U000027ea'),
- ('\U000027ec', '\U000027ec'),
- ('\U000027ee', '\U000027ee'),
- ('\U00002983', '\U00002983'),
- ('\U00002985', '\U00002985'),
- ('\U00002987', '\U00002987'),
- ('\U00002989', '\U00002989'),
- ('\U0000298b', '\U0000298b'),
- ('\U0000298d', '\U0000298d'),
- ('\U0000298f', '\U0000298f'),
- ('\U00002991', '\U00002991'),
- ('\U00002993', '\U00002993'),
- ('\U00002995', '\U00002995'),
- ('\U00002997', '\U00002997'),
- ('\U000029d8', '\U000029d8'),
- ('\U000029da', '\U000029da'),
- ('\U000029fc', '\U000029fc'),
- ('\U00002e22', '\U00002e22'),
- ('\U00002e24', '\U00002e24'),
- ('\U00002e26', '\U00002e26'),
- ('\U00002e28', '\U00002e28'),
- ('\U00003008', '\U00003008'),
- ('\U0000300a', '\U0000300a'),
- ('\U0000300c', '\U0000300c'),
- ('\U0000300e', '\U0000300e'),
- ('\U00003010', '\U00003010'),
- ('\U00003014', '\U00003014'),
- ('\U00003016', '\U00003016'),
- ('\U00003018', '\U00003018'),
- ('\U0000301a', '\U0000301a'),
- ('\U0000301d', '\U0000301d'),
- ('\U0000fd3e', '\U0000fd3e'),
- ('\U0000fe17', '\U0000fe17'),
- ('\U0000fe35', '\U0000fe35'),
- ('\U0000fe37', '\U0000fe37'),
- ('\U0000fe39', '\U0000fe39'),
- ('\U0000fe3b', '\U0000fe3b'),
- ('\U0000fe3d', '\U0000fe3d'),
- ('\U0000fe3f', '\U0000fe3f'),
- ('\U0000fe41', '\U0000fe41'),
- ('\U0000fe43', '\U0000fe43'),
- ('\U0000fe47', '\U0000fe47'),
- ('\U0000fe59', '\U0000fe59'),
- ('\U0000fe5b', '\U0000fe5b'),
- ('\U0000fe5d', '\U0000fe5d'),
- ('\U0000ff08', '\U0000ff08'),
- ('\U0000ff3b', '\U0000ff3b'),
- ('\U0000ff5b', '\U0000ff5b'),
- ('\U0000ff5f', '\U0000ff5f'),
- ('\U0000ff62', '\U0000ff62')
- ]),
-("Rejang", &[
- ('\U0000a930', '\U0000a953'),
- ('\U0000a95f', '\U0000a95f')
- ]),
-("Runic", &[
- ('\U000016a0', '\U000016ea'),
- ('\U000016ee', '\U000016f0')
- ]),
-("S", &[
- ('\U00000024', '\U00000024'),
- ('\U0000002b', '\U0000002b'),
- ('\U0000003c', '\U0000003e'),
- ('\U0000005e', '\U0000005e'),
- ('\U00000060', '\U00000060'),
- ('\U0000007c', '\U0000007c'),
- ('\U0000007e', '\U0000007e'),
- ('\U000000a2', '\U000000a6'),
- ('\U000000a8', '\U000000a9'),
- ('\U000000ac', '\U000000ac'),
- ('\U000000ae', '\U000000b1'),
- ('\U000000b4', '\U000000b4'),
- ('\U000000b8', '\U000000b8'),
- ('\U000000d7', '\U000000d7'),
- ('\U000000f7', '\U000000f7'),
- ('\U000002c2', '\U000002c5'),
- ('\U000002d2', '\U000002df'),
- ('\U000002e5', '\U000002eb'),
- ('\U000002ed', '\U000002ed'),
- ('\U000002ef', '\U000002ff'),
- ('\U00000375', '\U00000375'),
- ('\U00000384', '\U00000385'),
- ('\U000003f6', '\U000003f6'),
- ('\U00000482', '\U00000482'),
- ('\U0000058f', '\U0000058f'),
- ('\U00000606', '\U00000608'),
- ('\U0000060b', '\U0000060b'),
- ('\U0000060e', '\U0000060f'),
- ('\U000006de', '\U000006de'),
- ('\U000006e9', '\U000006e9'),
- ('\U000006fd', '\U000006fe'),
- ('\U000007f6', '\U000007f6'),
- ('\U000009f2', '\U000009f3'),
- ('\U000009fa', '\U000009fb'),
- ('\U00000af1', '\U00000af1'),
- ('\U00000b70', '\U00000b70'),
- ('\U00000bf3', '\U00000bfa'),
- ('\U00000c7f', '\U00000c7f'),
- ('\U00000d79', '\U00000d79'),
- ('\U00000e3f', '\U00000e3f'),
- ('\U00000f01', '\U00000f03'),
- ('\U00000f13', '\U00000f13'),
- ('\U00000f15', '\U00000f17'),
- ('\U00000f1a', '\U00000f1f'),
- ('\U00000f34', '\U00000f34'),
- ('\U00000f36', '\U00000f36'),
- ('\U00000f38', '\U00000f38'),
- ('\U00000fbe', '\U00000fc5'),
- ('\U00000fc7', '\U00000fcc'),
- ('\U00000fce', '\U00000fcf'),
- ('\U00000fd5', '\U00000fd8'),
- ('\U0000109e', '\U0000109f'),
- ('\U00001390', '\U00001399'),
- ('\U000017db', '\U000017db'),
- ('\U00001940', '\U00001940'),
- ('\U000019de', '\U000019ff'),
- ('\U00001b61', '\U00001b6a'),
- ('\U00001b74', '\U00001b7c'),
- ('\U00001fbd', '\U00001fbd'),
- ('\U00001fbf', '\U00001fc1'),
- ('\U00001fcd', '\U00001fcf'),
- ('\U00001fdd', '\U00001fdf'),
- ('\U00001fed', '\U00001fef'),
- ('\U00001ffd', '\U00001ffe'),
- ('\U00002044', '\U00002044'),
- ('\U00002052', '\U00002052'),
- ('\U0000207a', '\U0000207c'),
- ('\U0000208a', '\U0000208c'),
- ('\U000020a0', '\U000020ba'),
- ('\U00002100', '\U00002101'),
- ('\U00002103', '\U00002106'),
- ('\U00002108', '\U00002109'),
- ('\U00002114', '\U00002114'),
- ('\U00002116', '\U00002118'),
- ('\U0000211e', '\U00002123'),
- ('\U00002125', '\U00002125'),
- ('\U00002127', '\U00002127'),
- ('\U00002129', '\U00002129'),
- ('\U0000212e', '\U0000212e'),
- ('\U0000213a', '\U0000213b'),
- ('\U00002140', '\U00002144'),
- ('\U0000214a', '\U0000214d'),
- ('\U0000214f', '\U0000214f'),
- ('\U00002190', '\U00002307'),
- ('\U0000230c', '\U00002328'),
- ('\U0000232b', '\U000023f3'),
- ('\U00002400', '\U00002426'),
- ('\U00002440', '\U0000244a'),
- ('\U0000249c', '\U000024e9'),
- ('\U00002500', '\U000026ff'),
- ('\U00002701', '\U00002767'),
- ('\U00002794', '\U000027c4'),
- ('\U000027c7', '\U000027e5'),
- ('\U000027f0', '\U00002982'),
- ('\U00002999', '\U000029d7'),
- ('\U000029dc', '\U000029fb'),
- ('\U000029fe', '\U00002b4c'),
- ('\U00002b50', '\U00002b59'),
- ('\U00002ce5', '\U00002cea'),
- ('\U00002e80', '\U00002e99'),
- ('\U00002e9b', '\U00002ef3'),
- ('\U00002f00', '\U00002fd5'),
- ('\U00002ff0', '\U00002ffb'),
- ('\U00003004', '\U00003004'),
- ('\U00003012', '\U00003013'),
- ('\U00003020', '\U00003020'),
- ('\U00003036', '\U00003037'),
- ('\U0000303e', '\U0000303f'),
- ('\U0000309b', '\U0000309c'),
- ('\U00003190', '\U00003191'),
- ('\U00003196', '\U0000319f'),
- ('\U000031c0', '\U000031e3'),
- ('\U00003200', '\U0000321e'),
- ('\U0000322a', '\U00003247'),
- ('\U00003250', '\U00003250'),
- ('\U00003260', '\U0000327f'),
- ('\U0000328a', '\U000032b0'),
- ('\U000032c0', '\U000032fe'),
- ('\U00003300', '\U000033ff'),
- ('\U00004dc0', '\U00004dff'),
- ('\U0000a490', '\U0000a4c6'),
- ('\U0000a700', '\U0000a716'),
- ('\U0000a720', '\U0000a721'),
- ('\U0000a789', '\U0000a78a'),
- ('\U0000a828', '\U0000a82b'),
- ('\U0000a836', '\U0000a839'),
- ('\U0000aa77', '\U0000aa79'),
- ('\U0000fb29', '\U0000fb29'),
- ('\U0000fbb2', '\U0000fbc1'),
- ('\U0000fdfc', '\U0000fdfd'),
- ('\U0000fe62', '\U0000fe62'),
- ('\U0000fe64', '\U0000fe66'),
- ('\U0000fe69', '\U0000fe69'),
- ('\U0000ff04', '\U0000ff04'),
- ('\U0000ff0b', '\U0000ff0b'),
- ('\U0000ff1c', '\U0000ff1e'),
- ('\U0000ff3e', '\U0000ff3e'),
- ('\U0000ff40', '\U0000ff40'),
- ('\U0000ff5c', '\U0000ff5c'),
- ('\U0000ff5e', '\U0000ff5e'),
- ('\U0000ffe0', '\U0000ffe6'),
- ('\U0000ffe8', '\U0000ffee'),
- ('\U0000fffc', '\U0000fffd'),
- ('\U00010137', '\U0001013f'),
- ('\U00010179', '\U00010189'),
- ('\U00010190', '\U0001019b'),
- ('\U000101d0', '\U000101fc'),
- ('\U0001d000', '\U0001d0f5'),
- ('\U0001d100', '\U0001d126'),
- ('\U0001d129', '\U0001d164'),
- ('\U0001d16a', '\U0001d16c'),
- ('\U0001d183', '\U0001d184'),
- ('\U0001d18c', '\U0001d1a9'),
- ('\U0001d1ae', '\U0001d1dd'),
- ('\U0001d200', '\U0001d241'),
- ('\U0001d245', '\U0001d245'),
- ('\U0001d300', '\U0001d356'),
- ('\U0001d6c1', '\U0001d6c1'),
- ('\U0001d6db', '\U0001d6db'),
- ('\U0001d6fb', '\U0001d6fb'),
- ('\U0001d715', '\U0001d715'),
- ('\U0001d735', '\U0001d735'),
- ('\U0001d74f', '\U0001d74f'),
- ('\U0001d76f', '\U0001d76f'),
- ('\U0001d789', '\U0001d789'),
- ('\U0001d7a9', '\U0001d7a9'),
- ('\U0001d7c3', '\U0001d7c3'),
- ('\U0001eef0', '\U0001eef1'),
- ('\U0001f000', '\U0001f02b'),
- ('\U0001f030', '\U0001f093'),
- ('\U0001f0a0', '\U0001f0ae'),
- ('\U0001f0b1', '\U0001f0be'),
- ('\U0001f0c1', '\U0001f0cf'),
- ('\U0001f0d1', '\U0001f0df'),
- ('\U0001f110', '\U0001f12e'),
- ('\U0001f130', '\U0001f16b'),
- ('\U0001f170', '\U0001f19a'),
- ('\U0001f1e6', '\U0001f202'),
- ('\U0001f210', '\U0001f23a'),
- ('\U0001f240', '\U0001f248'),
- ('\U0001f250', '\U0001f251'),
- ('\U0001f300', '\U0001f320'),
- ('\U0001f330', '\U0001f335'),
- ('\U0001f337', '\U0001f37c'),
- ('\U0001f380', '\U0001f393'),
- ('\U0001f3a0', '\U0001f3c4'),
- ('\U0001f3c6', '\U0001f3ca'),
- ('\U0001f3e0', '\U0001f3f0'),
- ('\U0001f400', '\U0001f43e'),
- ('\U0001f440', '\U0001f440'),
- ('\U0001f442', '\U0001f4f7'),
- ('\U0001f4f9', '\U0001f4fc'),
- ('\U0001f500', '\U0001f53d'),
- ('\U0001f540', '\U0001f543'),
- ('\U0001f550', '\U0001f567'),
- ('\U0001f5fb', '\U0001f640'),
- ('\U0001f645', '\U0001f64f'),
- ('\U0001f680', '\U0001f6c5'),
- ('\U0001f700', '\U0001f773')
- ]),
-("Samaritan", &[
- ('\U00000800', '\U0000082d'),
- ('\U00000830', '\U0000083e')
- ]),
-("Saurashtra", &[
- ('\U0000a880', '\U0000a8c4'),
- ('\U0000a8ce', '\U0000a8d9')
- ]),
-("Sc", &[
- ('\U00000024', '\U00000024'),
- ('\U000000a2', '\U000000a5'),
- ('\U0000058f', '\U0000058f'),
- ('\U0000060b', '\U0000060b'),
- ('\U000009f2', '\U000009f3'),
- ('\U000009fb', '\U000009fb'),
- ('\U00000af1', '\U00000af1'),
- ('\U00000bf9', '\U00000bf9'),
- ('\U00000e3f', '\U00000e3f'),
- ('\U000017db', '\U000017db'),
- ('\U000020a0', '\U000020ba'),
- ('\U0000a838', '\U0000a838'),
- ('\U0000fdfc', '\U0000fdfc'),
- ('\U0000fe69', '\U0000fe69'),
- ('\U0000ff04', '\U0000ff04'),
- ('\U0000ffe0', '\U0000ffe1'),
- ('\U0000ffe5', '\U0000ffe6')
- ]),
-("Sharada", &[
- ('\U00011180', '\U000111c8'),
- ('\U000111d0', '\U000111d9')
- ]),
-("Shavian", &[
- ('\U00010450', '\U0001047f')
- ]),
-("Sinhala", &[
- ('\U00000d82', '\U00000d83'),
- ('\U00000d85', '\U00000d96'),
- ('\U00000d9a', '\U00000db1'),
- ('\U00000db3', '\U00000dbb'),
- ('\U00000dbd', '\U00000dbd'),
- ('\U00000dc0', '\U00000dc6'),
- ('\U00000dca', '\U00000dca'),
- ('\U00000dcf', '\U00000dd4'),
- ('\U00000dd6', '\U00000dd6'),
- ('\U00000dd8', '\U00000ddf'),
- ('\U00000df2', '\U00000df4')
- ]),
-("Sk", &[
- ('\U0000005e', '\U0000005e'),
- ('\U00000060', '\U00000060'),
- ('\U000000a8', '\U000000a8'),
- ('\U000000af', '\U000000af'),
- ('\U000000b4', '\U000000b4'),
- ('\U000000b8', '\U000000b8'),
- ('\U000002c2', '\U000002c5'),
- ('\U000002d2', '\U000002df'),
- ('\U000002e5', '\U000002eb'),
- ('\U000002ed', '\U000002ed'),
- ('\U000002ef', '\U000002ff'),
- ('\U00000375', '\U00000375'),
- ('\U00000384', '\U00000385'),
- ('\U00001fbd', '\U00001fbd'),
- ('\U00001fbf', '\U00001fc1'),
- ('\U00001fcd', '\U00001fcf'),
- ('\U00001fdd', '\U00001fdf'),
- ('\U00001fed', '\U00001fef'),
- ('\U00001ffd', '\U00001ffe'),
- ('\U0000309b', '\U0000309c'),
- ('\U0000a700', '\U0000a716'),
- ('\U0000a720', '\U0000a721'),
- ('\U0000a789', '\U0000a78a'),
- ('\U0000fbb2', '\U0000fbc1'),
- ('\U0000ff3e', '\U0000ff3e'),
- ('\U0000ff40', '\U0000ff40'),
- ('\U0000ffe3', '\U0000ffe3')
- ]),
-("Sm", &[
- ('\U0000002b', '\U0000002b'),
- ('\U0000003c', '\U0000003e'),
- ('\U0000007c', '\U0000007c'),
- ('\U0000007e', '\U0000007e'),
- ('\U000000ac', '\U000000ac'),
- ('\U000000b1', '\U000000b1'),
- ('\U000000d7', '\U000000d7'),
- ('\U000000f7', '\U000000f7'),
- ('\U000003f6', '\U000003f6'),
- ('\U00000606', '\U00000608'),
- ('\U00002044', '\U00002044'),
- ('\U00002052', '\U00002052'),
- ('\U0000207a', '\U0000207c'),
- ('\U0000208a', '\U0000208c'),
- ('\U00002118', '\U00002118'),
- ('\U00002140', '\U00002144'),
- ('\U0000214b', '\U0000214b'),
- ('\U00002190', '\U00002194'),
- ('\U0000219a', '\U0000219b'),
- ('\U000021a0', '\U000021a0'),
- ('\U000021a3', '\U000021a3'),
- ('\U000021a6', '\U000021a6'),
- ('\U000021ae', '\U000021ae'),
- ('\U000021ce', '\U000021cf'),
- ('\U000021d2', '\U000021d2'),
- ('\U000021d4', '\U000021d4'),
- ('\U000021f4', '\U000022ff'),
- ('\U00002320', '\U00002321'),
- ('\U0000237c', '\U0000237c'),
- ('\U0000239b', '\U000023b3'),
- ('\U000023dc', '\U000023e1'),
- ('\U000025b7', '\U000025b7'),
- ('\U000025c1', '\U000025c1'),
- ('\U000025f8', '\U000025ff'),
- ('\U0000266f', '\U0000266f'),
- ('\U000027c0', '\U000027c4'),
- ('\U000027c7', '\U000027e5'),
- ('\U000027f0', '\U000027ff'),
- ('\U00002900', '\U00002982'),
- ('\U00002999', '\U000029d7'),
- ('\U000029dc', '\U000029fb'),
- ('\U000029fe', '\U00002aff'),
- ('\U00002b30', '\U00002b44'),
- ('\U00002b47', '\U00002b4c'),
- ('\U0000fb29', '\U0000fb29'),
- ('\U0000fe62', '\U0000fe62'),
- ('\U0000fe64', '\U0000fe66'),
- ('\U0000ff0b', '\U0000ff0b'),
- ('\U0000ff1c', '\U0000ff1e'),
- ('\U0000ff5c', '\U0000ff5c'),
- ('\U0000ff5e', '\U0000ff5e'),
- ('\U0000ffe2', '\U0000ffe2'),
- ('\U0000ffe9', '\U0000ffec'),
- ('\U0001d6c1', '\U0001d6c1'),
- ('\U0001d6db', '\U0001d6db'),
- ('\U0001d6fb', '\U0001d6fb'),
- ('\U0001d715', '\U0001d715'),
- ('\U0001d735', '\U0001d735'),
- ('\U0001d74f', '\U0001d74f'),
- ('\U0001d76f', '\U0001d76f'),
- ('\U0001d789', '\U0001d789'),
- ('\U0001d7a9', '\U0001d7a9'),
- ('\U0001d7c3', '\U0001d7c3'),
- ('\U0001eef0', '\U0001eef1')
- ]),
-("So", &[
- ('\U000000a6', '\U000000a6'),
- ('\U000000a9', '\U000000a9'),
- ('\U000000ae', '\U000000ae'),
- ('\U000000b0', '\U000000b0'),
- ('\U00000482', '\U00000482'),
- ('\U0000060e', '\U0000060f'),
- ('\U000006de', '\U000006de'),
- ('\U000006e9', '\U000006e9'),
- ('\U000006fd', '\U000006fe'),
- ('\U000007f6', '\U000007f6'),
- ('\U000009fa', '\U000009fa'),
- ('\U00000b70', '\U00000b70'),
- ('\U00000bf3', '\U00000bf8'),
- ('\U00000bfa', '\U00000bfa'),
- ('\U00000c7f', '\U00000c7f'),
- ('\U00000d79', '\U00000d79'),
- ('\U00000f01', '\U00000f03'),
- ('\U00000f13', '\U00000f13'),
- ('\U00000f15', '\U00000f17'),
- ('\U00000f1a', '\U00000f1f'),
- ('\U00000f34', '\U00000f34'),
- ('\U00000f36', '\U00000f36'),
- ('\U00000f38', '\U00000f38'),
- ('\U00000fbe', '\U00000fc5'),
- ('\U00000fc7', '\U00000fcc'),
- ('\U00000fce', '\U00000fcf'),
- ('\U00000fd5', '\U00000fd8'),
- ('\U0000109e', '\U0000109f'),
- ('\U00001390', '\U00001399'),
- ('\U00001940', '\U00001940'),
- ('\U000019de', '\U000019ff'),
- ('\U00001b61', '\U00001b6a'),
- ('\U00001b74', '\U00001b7c'),
- ('\U00002100', '\U00002101'),
- ('\U00002103', '\U00002106'),
- ('\U00002108', '\U00002109'),
- ('\U00002114', '\U00002114'),
- ('\U00002116', '\U00002117'),
- ('\U0000211e', '\U00002123'),
- ('\U00002125', '\U00002125'),
- ('\U00002127', '\U00002127'),
- ('\U00002129', '\U00002129'),
- ('\U0000212e', '\U0000212e'),
- ('\U0000213a', '\U0000213b'),
- ('\U0000214a', '\U0000214a'),
- ('\U0000214c', '\U0000214d'),
- ('\U0000214f', '\U0000214f'),
- ('\U00002195', '\U00002199'),
- ('\U0000219c', '\U0000219f'),
- ('\U000021a1', '\U000021a2'),
- ('\U000021a4', '\U000021a5'),
- ('\U000021a7', '\U000021ad'),
- ('\U000021af', '\U000021cd'),
- ('\U000021d0', '\U000021d1'),
- ('\U000021d3', '\U000021d3'),
- ('\U000021d5', '\U000021f3'),
- ('\U00002300', '\U00002307'),
- ('\U0000230c', '\U0000231f'),
- ('\U00002322', '\U00002328'),
- ('\U0000232b', '\U0000237b'),
- ('\U0000237d', '\U0000239a'),
- ('\U000023b4', '\U000023db'),
- ('\U000023e2', '\U000023f3'),
- ('\U00002400', '\U00002426'),
- ('\U00002440', '\U0000244a'),
- ('\U0000249c', '\U000024e9'),
- ('\U00002500', '\U000025b6'),
- ('\U000025b8', '\U000025c0'),
- ('\U000025c2', '\U000025f7'),
- ('\U00002600', '\U0000266e'),
- ('\U00002670', '\U000026ff'),
- ('\U00002701', '\U00002767'),
- ('\U00002794', '\U000027bf'),
- ('\U00002800', '\U000028ff'),
- ('\U00002b00', '\U00002b2f'),
- ('\U00002b45', '\U00002b46'),
- ('\U00002b50', '\U00002b59'),
- ('\U00002ce5', '\U00002cea'),
- ('\U00002e80', '\U00002e99'),
- ('\U00002e9b', '\U00002ef3'),
- ('\U00002f00', '\U00002fd5'),
- ('\U00002ff0', '\U00002ffb'),
- ('\U00003004', '\U00003004'),
- ('\U00003012', '\U00003013'),
- ('\U00003020', '\U00003020'),
- ('\U00003036', '\U00003037'),
- ('\U0000303e', '\U0000303f'),
- ('\U00003190', '\U00003191'),
- ('\U00003196', '\U0000319f'),
- ('\U000031c0', '\U000031e3'),
- ('\U00003200', '\U0000321e'),
- ('\U0000322a', '\U00003247'),
- ('\U00003250', '\U00003250'),
- ('\U00003260', '\U0000327f'),
- ('\U0000328a', '\U000032b0'),
- ('\U000032c0', '\U000032fe'),
- ('\U00003300', '\U000033ff'),
- ('\U00004dc0', '\U00004dff'),
- ('\U0000a490', '\U0000a4c6'),
- ('\U0000a828', '\U0000a82b'),
- ('\U0000a836', '\U0000a837'),
- ('\U0000a839', '\U0000a839'),
- ('\U0000aa77', '\U0000aa79'),
- ('\U0000fdfd', '\U0000fdfd'),
- ('\U0000ffe4', '\U0000ffe4'),
- ('\U0000ffe8', '\U0000ffe8'),
- ('\U0000ffed', '\U0000ffee'),
- ('\U0000fffc', '\U0000fffd'),
- ('\U00010137', '\U0001013f'),
- ('\U00010179', '\U00010189'),
- ('\U00010190', '\U0001019b'),
- ('\U000101d0', '\U000101fc'),
- ('\U0001d000', '\U0001d0f5'),
- ('\U0001d100', '\U0001d126'),
- ('\U0001d129', '\U0001d164'),
- ('\U0001d16a', '\U0001d16c'),
- ('\U0001d183', '\U0001d184'),
- ('\U0001d18c', '\U0001d1a9'),
- ('\U0001d1ae', '\U0001d1dd'),
- ('\U0001d200', '\U0001d241'),
- ('\U0001d245', '\U0001d245'),
- ('\U0001d300', '\U0001d356'),
- ('\U0001f000', '\U0001f02b'),
- ('\U0001f030', '\U0001f093'),
- ('\U0001f0a0', '\U0001f0ae'),
- ('\U0001f0b1', '\U0001f0be'),
- ('\U0001f0c1', '\U0001f0cf'),
- ('\U0001f0d1', '\U0001f0df'),
- ('\U0001f110', '\U0001f12e'),
- ('\U0001f130', '\U0001f16b'),
- ('\U0001f170', '\U0001f19a'),
- ('\U0001f1e6', '\U0001f202'),
- ('\U0001f210', '\U0001f23a'),
- ('\U0001f240', '\U0001f248'),
- ('\U0001f250', '\U0001f251'),
- ('\U0001f300', '\U0001f320'),
- ('\U0001f330', '\U0001f335'),
- ('\U0001f337', '\U0001f37c'),
- ('\U0001f380', '\U0001f393'),
- ('\U0001f3a0', '\U0001f3c4'),
- ('\U0001f3c6', '\U0001f3ca'),
- ('\U0001f3e0', '\U0001f3f0'),
- ('\U0001f400', '\U0001f43e'),
- ('\U0001f440', '\U0001f440'),
- ('\U0001f442', '\U0001f4f7'),
- ('\U0001f4f9', '\U0001f4fc'),
- ('\U0001f500', '\U0001f53d'),
- ('\U0001f540', '\U0001f543'),
- ('\U0001f550', '\U0001f567'),
- ('\U0001f5fb', '\U0001f640'),
- ('\U0001f645', '\U0001f64f'),
- ('\U0001f680', '\U0001f6c5'),
- ('\U0001f700', '\U0001f773')
- ]),
-("Sora_Sompeng", &[
- ('\U000110d0', '\U000110e8'),
- ('\U000110f0', '\U000110f9')
- ]),
-("Sundanese", &[
- ('\U00001b80', '\U00001bbf'),
- ('\U00001cc0', '\U00001cc7')
- ]),
-("Syloti_Nagri", &[
- ('\U0000a800', '\U0000a82b')
- ]),
-("Syriac", &[
- ('\U00000700', '\U0000070d'),
- ('\U0000070f', '\U0000074a'),
- ('\U0000074d', '\U0000074f')
- ]),
-("Tagalog", &[
- ('\U00001700', '\U0000170c'),
- ('\U0000170e', '\U00001714')
- ]),
-("Tagbanwa", &[
- ('\U00001760', '\U0000176c'),
- ('\U0000176e', '\U00001770'),
- ('\U00001772', '\U00001773')
- ]),
-("Tai_Le", &[
- ('\U00001950', '\U0000196d'),
- ('\U00001970', '\U00001974')
- ]),
-("Tai_Tham", &[
- ('\U00001a20', '\U00001a5e'),
- ('\U00001a60', '\U00001a7c'),
- ('\U00001a7f', '\U00001a89'),
- ('\U00001a90', '\U00001a99'),
- ('\U00001aa0', '\U00001aad')
- ]),
-("Tai_Viet", &[
- ('\U0000aa80', '\U0000aac2'),
- ('\U0000aadb', '\U0000aadf')
- ]),
-("Takri", &[
- ('\U00011680', '\U000116b7'),
- ('\U000116c0', '\U000116c9')
- ]),
-("Tamil", &[
- ('\U00000b82', '\U00000b83'),
- ('\U00000b85', '\U00000b8a'),
- ('\U00000b8e', '\U00000b90'),
- ('\U00000b92', '\U00000b95'),
- ('\U00000b99', '\U00000b9a'),
- ('\U00000b9c', '\U00000b9c'),
- ('\U00000b9e', '\U00000b9f'),
- ('\U00000ba3', '\U00000ba4'),
- ('\U00000ba8', '\U00000baa'),
- ('\U00000bae', '\U00000bb9'),
- ('\U00000bbe', '\U00000bc2'),
- ('\U00000bc6', '\U00000bc8'),
- ('\U00000bca', '\U00000bcd'),
- ('\U00000bd0', '\U00000bd0'),
- ('\U00000bd7', '\U00000bd7'),
- ('\U00000be6', '\U00000bfa')
- ]),
-("Telugu", &[
- ('\U00000c01', '\U00000c03'),
- ('\U00000c05', '\U00000c0c'),
- ('\U00000c0e', '\U00000c10'),
- ('\U00000c12', '\U00000c28'),
- ('\U00000c2a', '\U00000c33'),
- ('\U00000c35', '\U00000c39'),
- ('\U00000c3d', '\U00000c44'),
- ('\U00000c46', '\U00000c48'),
- ('\U00000c4a', '\U00000c4d'),
- ('\U00000c55', '\U00000c56'),
- ('\U00000c58', '\U00000c59'),
- ('\U00000c60', '\U00000c63'),
- ('\U00000c66', '\U00000c6f'),
- ('\U00000c78', '\U00000c7f')
- ]),
-("Thaana", &[
- ('\U00000780', '\U000007b1')
- ]),
-("Thai", &[
- ('\U00000e01', '\U00000e3a'),
- ('\U00000e40', '\U00000e5b')
- ]),
-("Tibetan", &[
- ('\U00000f00', '\U00000f47'),
- ('\U00000f49', '\U00000f6c'),
- ('\U00000f71', '\U00000f97'),
- ('\U00000f99', '\U00000fbc'),
- ('\U00000fbe', '\U00000fcc'),
- ('\U00000fce', '\U00000fd4'),
- ('\U00000fd9', '\U00000fda')
- ]),
-("Tifinagh", &[
- ('\U00002d30', '\U00002d67'),
- ('\U00002d6f', '\U00002d70'),
- ('\U00002d7f', '\U00002d7f')
- ]),
-("Ugaritic", &[
- ('\U00010380', '\U0001039d'),
- ('\U0001039f', '\U0001039f')
- ]),
-("Vai", &[
- ('\U0000a500', '\U0000a62b')
- ]),
-("Yi", &[
- ('\U0000a000', '\U0000a48c'),
- ('\U0000a490', '\U0000a4c6')
- ]),
-("Z", &[
- ('\U00000020', '\U00000020'),
- ('\U000000a0', '\U000000a0'),
- ('\U00001680', '\U00001680'),
- ('\U00002000', '\U0000200a'),
- ('\U00002028', '\U00002029'),
- ('\U0000202f', '\U0000202f'),
- ('\U0000205f', '\U0000205f'),
- ('\U00003000', '\U00003000')
- ]),
-("Zl", &[
- ('\U00002028', '\U00002028')
- ]),
-("Zp", &[
- ('\U00002029', '\U00002029')
- ]),
-("Zs", &[
- ('\U00000020', '\U00000020'),
- ('\U000000a0', '\U000000a0'),
- ('\U00001680', '\U00001680'),
- ('\U00002000', '\U0000200a'),
- ('\U0000202f', '\U0000202f'),
- ('\U0000205f', '\U0000205f'),
- ('\U00003000', '\U00003000')
- ]),
-
-];
-
-pub static PERLD: Class = &[
- ('\U00000030', '\U00000039'),
- ('\U00000660', '\U00000669'),
- ('\U000006f0', '\U000006f9'),
- ('\U000007c0', '\U000007c9'),
- ('\U00000966', '\U0000096f'),
- ('\U000009e6', '\U000009ef'),
- ('\U00000a66', '\U00000a6f'),
- ('\U00000ae6', '\U00000aef'),
- ('\U00000b66', '\U00000b6f'),
- ('\U00000be6', '\U00000bef'),
- ('\U00000c66', '\U00000c6f'),
- ('\U00000ce6', '\U00000cef'),
- ('\U00000d66', '\U00000d6f'),
- ('\U00000e50', '\U00000e59'),
- ('\U00000ed0', '\U00000ed9'),
- ('\U00000f20', '\U00000f29'),
- ('\U00001040', '\U00001049'),
- ('\U00001090', '\U00001099'),
- ('\U000017e0', '\U000017e9'),
- ('\U00001810', '\U00001819'),
- ('\U00001946', '\U0000194f'),
- ('\U000019d0', '\U000019d9'),
- ('\U00001a80', '\U00001a89'),
- ('\U00001a90', '\U00001a99'),
- ('\U00001b50', '\U00001b59'),
- ('\U00001bb0', '\U00001bb9'),
- ('\U00001c40', '\U00001c49'),
- ('\U00001c50', '\U00001c59'),
- ('\U0000a620', '\U0000a629'),
- ('\U0000a8d0', '\U0000a8d9'),
- ('\U0000a900', '\U0000a909'),
- ('\U0000a9d0', '\U0000a9d9'),
- ('\U0000aa50', '\U0000aa59'),
- ('\U0000abf0', '\U0000abf9'),
- ('\U0000ff10', '\U0000ff19'),
- ('\U000104a0', '\U000104a9'),
- ('\U00011066', '\U0001106f'),
- ('\U000110f0', '\U000110f9'),
- ('\U00011136', '\U0001113f'),
- ('\U000111d0', '\U000111d9'),
- ('\U000116c0', '\U000116c9'),
- ('\U0001d7ce', '\U0001d7ff')
-];
-
-pub static PERLS: Class = &[
- ('\U00000009', '\U0000000a'),
- ('\U0000000c', '\U0000000d'),
- ('\U00000020', '\U00000020'),
- ('\U000000a0', '\U000000a0'),
- ('\U00001680', '\U00001680'),
- ('\U00002000', '\U0000200a'),
- ('\U00002028', '\U00002029'),
- ('\U0000202f', '\U0000202f'),
- ('\U0000205f', '\U0000205f'),
- ('\U00003000', '\U00003000')
-];
-
-pub static PERLW: Class = &[
- ('\U00000030', '\U00000039'),
- ('\U00000041', '\U0000005a'),
- ('\U0000005f', '\U0000005f'),
- ('\U00000061', '\U0000007a'),
- ('\U000000aa', '\U000000aa'),
- ('\U000000b5', '\U000000b5'),
- ('\U000000ba', '\U000000ba'),
- ('\U000000c0', '\U000000d6'),
- ('\U000000d8', '\U000000f6'),
- ('\U000000f8', '\U000002c1'),
- ('\U000002c6', '\U000002d1'),
- ('\U000002e0', '\U000002e4'),
- ('\U000002ec', '\U000002ec'),
- ('\U000002ee', '\U000002ee'),
- ('\U00000370', '\U00000374'),
- ('\U00000376', '\U00000377'),
- ('\U0000037a', '\U0000037d'),
- ('\U00000386', '\U00000386'),
- ('\U00000388', '\U0000038a'),
- ('\U0000038c', '\U0000038c'),
- ('\U0000038e', '\U000003a1'),
- ('\U000003a3', '\U000003f5'),
- ('\U000003f7', '\U00000481'),
- ('\U0000048a', '\U00000527'),
- ('\U00000531', '\U00000556'),
- ('\U00000559', '\U00000559'),
- ('\U00000561', '\U00000587'),
- ('\U000005d0', '\U000005ea'),
- ('\U000005f0', '\U000005f2'),
- ('\U00000620', '\U0000064a'),
- ('\U0000066e', '\U0000066f'),
- ('\U00000671', '\U000006d3'),
- ('\U000006d5', '\U000006d5'),
- ('\U000006e5', '\U000006e6'),
- ('\U000006ee', '\U000006ef'),
- ('\U000006fa', '\U000006fc'),
- ('\U000006ff', '\U000006ff'),
- ('\U00000710', '\U00000710'),
- ('\U00000712', '\U0000072f'),
- ('\U0000074d', '\U000007a5'),
- ('\U000007b1', '\U000007b1'),
- ('\U000007ca', '\U000007ea'),
- ('\U000007f4', '\U000007f5'),
- ('\U000007fa', '\U000007fa'),
- ('\U00000800', '\U00000815'),
- ('\U0000081a', '\U0000081a'),
- ('\U00000824', '\U00000824'),
- ('\U00000828', '\U00000828'),
- ('\U00000840', '\U00000858'),
- ('\U000008a0', '\U000008a0'),
- ('\U000008a2', '\U000008ac'),
- ('\U00000904', '\U00000939'),
- ('\U0000093d', '\U0000093d'),
- ('\U00000950', '\U00000950'),
- ('\U00000958', '\U00000961'),
- ('\U00000971', '\U00000977'),
- ('\U00000979', '\U0000097f'),
- ('\U00000985', '\U0000098c'),
- ('\U0000098f', '\U00000990'),
- ('\U00000993', '\U000009a8'),
- ('\U000009aa', '\U000009b0'),
- ('\U000009b2', '\U000009b2'),
- ('\U000009b6', '\U000009b9'),
- ('\U000009bd', '\U000009bd'),
- ('\U000009ce', '\U000009ce'),
- ('\U000009dc', '\U000009dd'),
- ('\U000009df', '\U000009e1'),
- ('\U000009f0', '\U000009f1'),
- ('\U00000a05', '\U00000a0a'),
- ('\U00000a0f', '\U00000a10'),
- ('\U00000a13', '\U00000a28'),
- ('\U00000a2a', '\U00000a30'),
- ('\U00000a32', '\U00000a33'),
- ('\U00000a35', '\U00000a36'),
- ('\U00000a38', '\U00000a39'),
- ('\U00000a59', '\U00000a5c'),
- ('\U00000a5e', '\U00000a5e'),
- ('\U00000a72', '\U00000a74'),
- ('\U00000a85', '\U00000a8d'),
- ('\U00000a8f', '\U00000a91'),
- ('\U00000a93', '\U00000aa8'),
- ('\U00000aaa', '\U00000ab0'),
- ('\U00000ab2', '\U00000ab3'),
- ('\U00000ab5', '\U00000ab9'),
- ('\U00000abd', '\U00000abd'),
- ('\U00000ad0', '\U00000ad0'),
- ('\U00000ae0', '\U00000ae1'),
- ('\U00000b05', '\U00000b0c'),
- ('\U00000b0f', '\U00000b10'),
- ('\U00000b13', '\U00000b28'),
- ('\U00000b2a', '\U00000b30'),
- ('\U00000b32', '\U00000b33'),
- ('\U00000b35', '\U00000b39'),
- ('\U00000b3d', '\U00000b3d'),
- ('\U00000b5c', '\U00000b5d'),
- ('\U00000b5f', '\U00000b61'),
- ('\U00000b71', '\U00000b71'),
- ('\U00000b83', '\U00000b83'),
- ('\U00000b85', '\U00000b8a'),
- ('\U00000b8e', '\U00000b90'),
- ('\U00000b92', '\U00000b95'),
- ('\U00000b99', '\U00000b9a'),
- ('\U00000b9c', '\U00000b9c'),
- ('\U00000b9e', '\U00000b9f'),
- ('\U00000ba3', '\U00000ba4'),
- ('\U00000ba8', '\U00000baa'),
- ('\U00000bae', '\U00000bb9'),
- ('\U00000bd0', '\U00000bd0'),
- ('\U00000c05', '\U00000c0c'),
- ('\U00000c0e', '\U00000c10'),
- ('\U00000c12', '\U00000c28'),
- ('\U00000c2a', '\U00000c33'),
- ('\U00000c35', '\U00000c39'),
- ('\U00000c3d', '\U00000c3d'),
- ('\U00000c58', '\U00000c59'),
- ('\U00000c60', '\U00000c61'),
- ('\U00000c85', '\U00000c8c'),
- ('\U00000c8e', '\U00000c90'),
- ('\U00000c92', '\U00000ca8'),
- ('\U00000caa', '\U00000cb3'),
- ('\U00000cb5', '\U00000cb9'),
- ('\U00000cbd', '\U00000cbd'),
- ('\U00000cde', '\U00000cde'),
- ('\U00000ce0', '\U00000ce1'),
- ('\U00000cf1', '\U00000cf2'),
- ('\U00000d05', '\U00000d0c'),
- ('\U00000d0e', '\U00000d10'),
- ('\U00000d12', '\U00000d3a'),
- ('\U00000d3d', '\U00000d3d'),
- ('\U00000d4e', '\U00000d4e'),
- ('\U00000d60', '\U00000d61'),
- ('\U00000d7a', '\U00000d7f'),
- ('\U00000d85', '\U00000d96'),
- ('\U00000d9a', '\U00000db1'),
- ('\U00000db3', '\U00000dbb'),
- ('\U00000dbd', '\U00000dbd'),
- ('\U00000dc0', '\U00000dc6'),
- ('\U00000e01', '\U00000e30'),
- ('\U00000e32', '\U00000e33'),
- ('\U00000e40', '\U00000e46'),
- ('\U00000e81', '\U00000e82'),
- ('\U00000e84', '\U00000e84'),
- ('\U00000e87', '\U00000e88'),
- ('\U00000e8a', '\U00000e8a'),
- ('\U00000e8d', '\U00000e8d'),
- ('\U00000e94', '\U00000e97'),
- ('\U00000e99', '\U00000e9f'),
- ('\U00000ea1', '\U00000ea3'),
- ('\U00000ea5', '\U00000ea5'),
- ('\U00000ea7', '\U00000ea7'),
- ('\U00000eaa', '\U00000eab'),
- ('\U00000ead', '\U00000eb0'),
- ('\U00000eb2', '\U00000eb3'),
- ('\U00000ebd', '\U00000ebd'),
- ('\U00000ec0', '\U00000ec4'),
- ('\U00000ec6', '\U00000ec6'),
- ('\U00000edc', '\U00000edf'),
- ('\U00000f00', '\U00000f00'),
- ('\U00000f40', '\U00000f47'),
- ('\U00000f49', '\U00000f6c'),
- ('\U00000f88', '\U00000f8c'),
- ('\U00001000', '\U0000102a'),
- ('\U0000103f', '\U0000103f'),
- ('\U00001050', '\U00001055'),
- ('\U0000105a', '\U0000105d'),
- ('\U00001061', '\U00001061'),
- ('\U00001065', '\U00001066'),
- ('\U0000106e', '\U00001070'),
- ('\U00001075', '\U00001081'),
- ('\U0000108e', '\U0000108e'),
- ('\U000010a0', '\U000010c5'),
- ('\U000010c7', '\U000010c7'),
- ('\U000010cd', '\U000010cd'),
- ('\U000010d0', '\U000010fa'),
- ('\U000010fc', '\U00001248'),
- ('\U0000124a', '\U0000124d'),
- ('\U00001250', '\U00001256'),
- ('\U00001258', '\U00001258'),
- ('\U0000125a', '\U0000125d'),
- ('\U00001260', '\U00001288'),
- ('\U0000128a', '\U0000128d'),
- ('\U00001290', '\U000012b0'),
- ('\U000012b2', '\U000012b5'),
- ('\U000012b8', '\U000012be'),
- ('\U000012c0', '\U000012c0'),
- ('\U000012c2', '\U000012c5'),
- ('\U000012c8', '\U000012d6'),
- ('\U000012d8', '\U00001310'),
- ('\U00001312', '\U00001315'),
- ('\U00001318', '\U0000135a'),
- ('\U00001380', '\U0000138f'),
- ('\U000013a0', '\U000013f4'),
- ('\U00001401', '\U0000166c'),
- ('\U0000166f', '\U0000167f'),
- ('\U00001681', '\U0000169a'),
- ('\U000016a0', '\U000016ea'),
- ('\U00001700', '\U0000170c'),
- ('\U0000170e', '\U00001711'),
- ('\U00001720', '\U00001731'),
- ('\U00001740', '\U00001751'),
- ('\U00001760', '\U0000176c'),
- ('\U0000176e', '\U00001770'),
- ('\U00001780', '\U000017b3'),
- ('\U000017d7', '\U000017d7'),
- ('\U000017dc', '\U000017dc'),
- ('\U00001820', '\U00001877'),
- ('\U00001880', '\U000018a8'),
- ('\U000018aa', '\U000018aa'),
- ('\U000018b0', '\U000018f5'),
- ('\U00001900', '\U0000191c'),
- ('\U00001950', '\U0000196d'),
- ('\U00001970', '\U00001974'),
- ('\U00001980', '\U000019ab'),
- ('\U000019c1', '\U000019c7'),
- ('\U00001a00', '\U00001a16'),
- ('\U00001a20', '\U00001a54'),
- ('\U00001aa7', '\U00001aa7'),
- ('\U00001b05', '\U00001b33'),
- ('\U00001b45', '\U00001b4b'),
- ('\U00001b83', '\U00001ba0'),
- ('\U00001bae', '\U00001baf'),
- ('\U00001bba', '\U00001be5'),
- ('\U00001c00', '\U00001c23'),
- ('\U00001c4d', '\U00001c4f'),
- ('\U00001c5a', '\U00001c7d'),
- ('\U00001ce9', '\U00001cec'),
- ('\U00001cee', '\U00001cf1'),
- ('\U00001cf5', '\U00001cf6'),
- ('\U00001d00', '\U00001dbf'),
- ('\U00001e00', '\U00001f15'),
- ('\U00001f18', '\U00001f1d'),
- ('\U00001f20', '\U00001f45'),
- ('\U00001f48', '\U00001f4d'),
- ('\U00001f50', '\U00001f57'),
- ('\U00001f59', '\U00001f59'),
- ('\U00001f5b', '\U00001f5b'),
- ('\U00001f5d', '\U00001f5d'),
- ('\U00001f5f', '\U00001f7d'),
- ('\U00001f80', '\U00001fb4'),
- ('\U00001fb6', '\U00001fbc'),
- ('\U00001fbe', '\U00001fbe'),
- ('\U00001fc2', '\U00001fc4'),
- ('\U00001fc6', '\U00001fcc'),
- ('\U00001fd0', '\U00001fd3'),
- ('\U00001fd6', '\U00001fdb'),
- ('\U00001fe0', '\U00001fec'),
- ('\U00001ff2', '\U00001ff4'),
- ('\U00001ff6', '\U00001ffc'),
- ('\U00002071', '\U00002071'),
- ('\U0000207f', '\U0000207f'),
- ('\U00002090', '\U0000209c'),
- ('\U00002102', '\U00002102'),
- ('\U00002107', '\U00002107'),
- ('\U0000210a', '\U00002113'),
- ('\U00002115', '\U00002115'),
- ('\U00002119', '\U0000211d'),
- ('\U00002124', '\U00002124'),
- ('\U00002126', '\U00002126'),
- ('\U00002128', '\U00002128'),
- ('\U0000212a', '\U0000212d'),
- ('\U0000212f', '\U00002139'),
- ('\U0000213c', '\U0000213f'),
- ('\U00002145', '\U00002149'),
- ('\U0000214e', '\U0000214e'),
- ('\U00002183', '\U00002184'),
- ('\U00002c00', '\U00002c2e'),
- ('\U00002c30', '\U00002c5e'),
- ('\U00002c60', '\U00002ce4'),
- ('\U00002ceb', '\U00002cee'),
- ('\U00002cf2', '\U00002cf3'),
- ('\U00002d00', '\U00002d25'),
- ('\U00002d27', '\U00002d27'),
- ('\U00002d2d', '\U00002d2d'),
- ('\U00002d30', '\U00002d67'),
- ('\U00002d6f', '\U00002d6f'),
- ('\U00002d80', '\U00002d96'),
- ('\U00002da0', '\U00002da6'),
- ('\U00002da8', '\U00002dae'),
- ('\U00002db0', '\U00002db6'),
- ('\U00002db8', '\U00002dbe'),
- ('\U00002dc0', '\U00002dc6'),
- ('\U00002dc8', '\U00002dce'),
- ('\U00002dd0', '\U00002dd6'),
- ('\U00002dd8', '\U00002dde'),
- ('\U00002e2f', '\U00002e2f'),
- ('\U00003005', '\U00003006'),
- ('\U00003031', '\U00003035'),
- ('\U0000303b', '\U0000303c'),
- ('\U00003041', '\U00003096'),
- ('\U0000309d', '\U0000309f'),
- ('\U000030a1', '\U000030fa'),
- ('\U000030fc', '\U000030ff'),
- ('\U00003105', '\U0000312d'),
- ('\U00003131', '\U0000318e'),
- ('\U000031a0', '\U000031ba'),
- ('\U000031f0', '\U000031ff'),
- ('\U00003400', '\U00003400'),
- ('\U00004db5', '\U00004db5'),
- ('\U00004e00', '\U00004e00'),
- ('\U00009fcc', '\U00009fcc'),
- ('\U0000a000', '\U0000a48c'),
- ('\U0000a4d0', '\U0000a4fd'),
- ('\U0000a500', '\U0000a60c'),
- ('\U0000a610', '\U0000a61f'),
- ('\U0000a62a', '\U0000a62b'),
- ('\U0000a640', '\U0000a66e'),
- ('\U0000a67f', '\U0000a697'),
- ('\U0000a6a0', '\U0000a6e5'),
- ('\U0000a717', '\U0000a71f'),
- ('\U0000a722', '\U0000a788'),
- ('\U0000a78b', '\U0000a78e'),
- ('\U0000a790', '\U0000a793'),
- ('\U0000a7a0', '\U0000a7aa'),
- ('\U0000a7f8', '\U0000a801'),
- ('\U0000a803', '\U0000a805'),
- ('\U0000a807', '\U0000a80a'),
- ('\U0000a80c', '\U0000a822'),
- ('\U0000a840', '\U0000a873'),
- ('\U0000a882', '\U0000a8b3'),
- ('\U0000a8f2', '\U0000a8f7'),
- ('\U0000a8fb', '\U0000a8fb'),
- ('\U0000a90a', '\U0000a925'),
- ('\U0000a930', '\U0000a946'),
- ('\U0000a960', '\U0000a97c'),
- ('\U0000a984', '\U0000a9b2'),
- ('\U0000a9cf', '\U0000a9cf'),
- ('\U0000aa00', '\U0000aa28'),
- ('\U0000aa40', '\U0000aa42'),
- ('\U0000aa44', '\U0000aa4b'),
- ('\U0000aa60', '\U0000aa76'),
- ('\U0000aa7a', '\U0000aa7a'),
- ('\U0000aa80', '\U0000aaaf'),
- ('\U0000aab1', '\U0000aab1'),
- ('\U0000aab5', '\U0000aab6'),
- ('\U0000aab9', '\U0000aabd'),
- ('\U0000aac0', '\U0000aac0'),
- ('\U0000aac2', '\U0000aac2'),
- ('\U0000aadb', '\U0000aadd'),
- ('\U0000aae0', '\U0000aaea'),
- ('\U0000aaf2', '\U0000aaf4'),
- ('\U0000ab01', '\U0000ab06'),
- ('\U0000ab09', '\U0000ab0e'),
- ('\U0000ab11', '\U0000ab16'),
- ('\U0000ab20', '\U0000ab26'),
- ('\U0000ab28', '\U0000ab2e'),
- ('\U0000abc0', '\U0000abe2'),
- ('\U0000ac00', '\U0000ac00'),
- ('\U0000d7a3', '\U0000d7a3'),
- ('\U0000d7b0', '\U0000d7c6'),
- ('\U0000d7cb', '\U0000d7fb'),
- ('\U0000f900', '\U0000fa6d'),
- ('\U0000fa70', '\U0000fad9'),
- ('\U0000fb00', '\U0000fb06'),
- ('\U0000fb13', '\U0000fb17'),
- ('\U0000fb1d', '\U0000fb1d'),
- ('\U0000fb1f', '\U0000fb28'),
- ('\U0000fb2a', '\U0000fb36'),
- ('\U0000fb38', '\U0000fb3c'),
- ('\U0000fb3e', '\U0000fb3e'),
- ('\U0000fb40', '\U0000fb41'),
- ('\U0000fb43', '\U0000fb44'),
- ('\U0000fb46', '\U0000fbb1'),
- ('\U0000fbd3', '\U0000fd3d'),
- ('\U0000fd50', '\U0000fd8f'),
- ('\U0000fd92', '\U0000fdc7'),
- ('\U0000fdf0', '\U0000fdfb'),
- ('\U0000fe70', '\U0000fe74'),
- ('\U0000fe76', '\U0000fefc'),
- ('\U0000ff21', '\U0000ff3a'),
- ('\U0000ff41', '\U0000ff5a'),
- ('\U0000ff66', '\U0000ffbe'),
- ('\U0000ffc2', '\U0000ffc7'),
- ('\U0000ffca', '\U0000ffcf'),
- ('\U0000ffd2', '\U0000ffd7'),
- ('\U0000ffda', '\U0000ffdc'),
- ('\U00010000', '\U0001000b'),
- ('\U0001000d', '\U00010026'),
- ('\U00010028', '\U0001003a'),
- ('\U0001003c', '\U0001003d'),
- ('\U0001003f', '\U0001004d'),
- ('\U00010050', '\U0001005d'),
- ('\U00010080', '\U000100fa'),
- ('\U00010280', '\U0001029c'),
- ('\U000102a0', '\U000102d0'),
- ('\U00010300', '\U0001031e'),
- ('\U00010330', '\U00010340'),
- ('\U00010342', '\U00010349'),
- ('\U00010380', '\U0001039d'),
- ('\U000103a0', '\U000103c3'),
- ('\U000103c8', '\U000103cf'),
- ('\U00010400', '\U0001049d'),
- ('\U00010800', '\U00010805'),
- ('\U00010808', '\U00010808'),
- ('\U0001080a', '\U00010835'),
- ('\U00010837', '\U00010838'),
- ('\U0001083c', '\U0001083c'),
- ('\U0001083f', '\U00010855'),
- ('\U00010900', '\U00010915'),
- ('\U00010920', '\U00010939'),
- ('\U00010980', '\U000109b7'),
- ('\U000109be', '\U000109bf'),
- ('\U00010a00', '\U00010a00'),
- ('\U00010a10', '\U00010a13'),
- ('\U00010a15', '\U00010a17'),
- ('\U00010a19', '\U00010a33'),
- ('\U00010a60', '\U00010a7c'),
- ('\U00010b00', '\U00010b35'),
- ('\U00010b40', '\U00010b55'),
- ('\U00010b60', '\U00010b72'),
- ('\U00010c00', '\U00010c48'),
- ('\U00011003', '\U00011037'),
- ('\U00011083', '\U000110af'),
- ('\U000110d0', '\U000110e8'),
- ('\U00011103', '\U00011126'),
- ('\U00011183', '\U000111b2'),
- ('\U000111c1', '\U000111c4'),
- ('\U00011680', '\U000116aa'),
- ('\U00012000', '\U0001236e'),
- ('\U00013000', '\U0001342e'),
- ('\U00016800', '\U00016a38'),
- ('\U00016f00', '\U00016f44'),
- ('\U00016f50', '\U00016f50'),
- ('\U00016f93', '\U00016f9f'),
- ('\U0001b000', '\U0001b001'),
- ('\U0001d400', '\U0001d454'),
- ('\U0001d456', '\U0001d49c'),
- ('\U0001d49e', '\U0001d49f'),
- ('\U0001d4a2', '\U0001d4a2'),
- ('\U0001d4a5', '\U0001d4a6'),
- ('\U0001d4a9', '\U0001d4ac'),
- ('\U0001d4ae', '\U0001d4b9'),
- ('\U0001d4bb', '\U0001d4bb'),
- ('\U0001d4bd', '\U0001d4c3'),
- ('\U0001d4c5', '\U0001d505'),
- ('\U0001d507', '\U0001d50a'),
- ('\U0001d50d', '\U0001d514'),
- ('\U0001d516', '\U0001d51c'),
- ('\U0001d51e', '\U0001d539'),
- ('\U0001d53b', '\U0001d53e'),
- ('\U0001d540', '\U0001d544'),
- ('\U0001d546', '\U0001d546'),
- ('\U0001d54a', '\U0001d550'),
- ('\U0001d552', '\U0001d6a5'),
- ('\U0001d6a8', '\U0001d6c0'),
- ('\U0001d6c2', '\U0001d6da'),
- ('\U0001d6dc', '\U0001d6fa'),
- ('\U0001d6fc', '\U0001d714'),
- ('\U0001d716', '\U0001d734'),
- ('\U0001d736', '\U0001d74e'),
- ('\U0001d750', '\U0001d76e'),
- ('\U0001d770', '\U0001d788'),
- ('\U0001d78a', '\U0001d7a8'),
- ('\U0001d7aa', '\U0001d7c2'),
- ('\U0001d7c4', '\U0001d7cb'),
- ('\U0001ee00', '\U0001ee03'),
- ('\U0001ee05', '\U0001ee1f'),
- ('\U0001ee21', '\U0001ee22'),
- ('\U0001ee24', '\U0001ee24'),
- ('\U0001ee27', '\U0001ee27'),
- ('\U0001ee29', '\U0001ee32'),
- ('\U0001ee34', '\U0001ee37'),
- ('\U0001ee39', '\U0001ee39'),
- ('\U0001ee3b', '\U0001ee3b'),
- ('\U0001ee42', '\U0001ee42'),
- ('\U0001ee47', '\U0001ee47'),
- ('\U0001ee49', '\U0001ee49'),
- ('\U0001ee4b', '\U0001ee4b'),
- ('\U0001ee4d', '\U0001ee4f'),
- ('\U0001ee51', '\U0001ee52'),
- ('\U0001ee54', '\U0001ee54'),
- ('\U0001ee57', '\U0001ee57'),
- ('\U0001ee59', '\U0001ee59'),
- ('\U0001ee5b', '\U0001ee5b'),
- ('\U0001ee5d', '\U0001ee5d'),
- ('\U0001ee5f', '\U0001ee5f'),
- ('\U0001ee61', '\U0001ee62'),
- ('\U0001ee64', '\U0001ee64'),
- ('\U0001ee67', '\U0001ee6a'),
- ('\U0001ee6c', '\U0001ee72'),
- ('\U0001ee74', '\U0001ee77'),
- ('\U0001ee79', '\U0001ee7c'),
- ('\U0001ee7e', '\U0001ee7e'),
- ('\U0001ee80', '\U0001ee89'),
- ('\U0001ee8b', '\U0001ee9b'),
- ('\U0001eea1', '\U0001eea3'),
- ('\U0001eea5', '\U0001eea9'),
- ('\U0001eeab', '\U0001eebb'),
- ('\U00020000', '\U00020000'),
- ('\U0002a6d6', '\U0002a6d6'),
- ('\U0002a700', '\U0002a700'),
- ('\U0002b734', '\U0002b734'),
- ('\U0002b740', '\U0002b740'),
- ('\U0002b81d', '\U0002b81d'),
- ('\U0002f800', '\U0002fa1d')
-];
-
// Test the Unicode friendliness of Perl character classes.
mat!(uni_perl_w, r"\w+", "dδd", Some((0, 4)))
-mat!(uni_perl_w_not, r"\w+", "â\85¡", None)
-mat!(uni_perl_w_neg, r"\W+", "â\85¡", Some((0, 3)))
+mat!(uni_perl_w_not, r"\w+", "⥡", None)
+mat!(uni_perl_w_neg, r"\W+", "⥡", Some((0, 3)))
mat!(uni_perl_d, r"\d+", "1२३9", Some((0, 8)))
mat!(uni_perl_d_not, r"\d+", "Ⅱ", None)
mat!(uni_perl_d_neg, r"\D+", "Ⅱ", Some((0, 3)))
Save, Jump, Split,
};
use parse::{FLAG_NOCASE, FLAG_MULTI, FLAG_DOTNL, FLAG_NEGATED};
-use parse::unicode::PERLW;
+use unicode::regex::PERLW;
pub type CaptureLocs = Vec<Option<uint>>;
//! This crate provides the `regex!` macro. Its use is documented in the
//! `regex` crate.
-#![crate_id = "regex_macros#0.11.0"] // NOTE: remove after stage0
#![crate_name = "regex_macros"]
#![crate_type = "dylib"]
#![experimental]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![feature(plugin_registrar, managed_boxes, quote)]
//! necessary. It is an error to include this library when also linking with
//! the system libc library.
-#![crate_id = "rlibc#0.11.0"] // NOTE: remove after stage0
#![crate_name = "rlibc"]
#![license = "MIT/ASL2"]
#![crate_type = "rlib"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/")]
#![feature(intrinsics)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![no_std]
#![experimental]
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+register_diagnostic!(E0001, r##"
+ This error suggests that the expression arm corresponding to the noted pattern
+ will never be reached as for all possible values of the expression being matched,
+ one of the preceeding patterns will match.
+
+ This means that perhaps some of the preceeding patterns are too general, this
+ one is too specific or the ordering is incorrect.
+"##)
optopt("", "opt-level", "Optimize with possible levels 0-3", "LEVEL"),
optopt( "", "out-dir", "Write output to compiler-chosen filename in <dir>", "DIR"),
optflag("", "parse-only", "Parse only; do not compile, assemble, or link"),
+ optopt("", "explain", "Provide a detailed explanation of an error message", "OPT"),
optflagopt("", "pretty",
"Pretty-print the input instead of compiling;
valid types are: `normal` (un-annotated source),
use getopts::getopts;
use syntax::attr;
use syntax::attr::AttrMetaMethods;
+ use syntax::diagnostics;
// When the user supplies --test we should implicitly supply --cfg test
#[test]
Ok(m) => m,
Err(f) => fail!("test_switch_implies_cfg_test: {}", f)
};
+ let registry = diagnostics::registry::Registry::new([]);
let sessopts = build_session_options(matches);
- let sess = build_session(sessopts, None);
+ let sess = build_session(sessopts, None, registry);
let cfg = build_configuration(&sess);
assert!((attr::contains_name(cfg.as_slice(), "test")));
}
fail!("test_switch_implies_cfg_test_unless_cfg_test: {}", f)
}
};
+ let registry = diagnostics::registry::Registry::new([]);
let sessopts = build_session_options(matches);
- let sess = build_session(sessopts, None);
+ let sess = build_session(sessopts, None, registry);
let cfg = build_configuration(&sess);
let mut test_items = cfg.iter().filter(|m| m.name().equiv(&("test")));
assert!(test_items.next().is_some());
use driver::{PpmIdentified};
use front;
use lib::llvm::{ContextRef, ModuleRef};
+use lint;
use metadata::common::LinkMeta;
use metadata::creader;
use middle::cfg;
use plugin::load::Plugins;
use plugin::registry::Registry;
use plugin;
-use lint;
+
use util::common::time;
use util::ppaux;
use util::nodemap::{NodeSet};
use syntax::ast;
use syntax::attr;
use syntax::attr::{AttrMetaMethods};
+use syntax::diagnostics;
use syntax::parse;
use syntax::parse::token;
use syntax::print::{pp, pprust};
let mut registry = Registry::new(&krate);
time(time_passes, "plugin registration", (), |_| {
+ if sess.features.rustc_diagnostic_macros.get() {
+ registry.register_macro("__diagnostic_used",
+ diagnostics::plugin::expand_diagnostic_used);
+ registry.register_macro("__register_diagnostic",
+ diagnostics::plugin::expand_register_diagnostic);
+ registry.register_macro("__build_diagnostic_array",
+ diagnostics::plugin::expand_build_diagnostic_array);
+ }
+
for ®istrar in registrars.iter() {
registrar(&mut registry);
}
use syntax::ast;
use syntax::parse;
use syntax::diagnostic::Emitter;
+use syntax::diagnostics;
use getopts;
Some(matches) => matches,
None => return
};
- let sopts = config::build_session_options(&matches);
+ let descriptions = diagnostics::registry::Registry::new(super::DIAGNOSTICS);
+ match matches.opt_str("explain") {
+ Some(ref code) => {
+ match descriptions.find_description(code.as_slice()) {
+ Some(ref description) => {
+ println!("{}", description);
+ }
+ None => {
+ early_error(format!("no extended information for {}", code).as_slice());
+ }
+ }
+ return;
+ },
+ None => ()
+ }
+
+ let sopts = config::build_session_options(&matches);
let (input, input_file_path) = match matches.free.len() {
0u => {
if sopts.describe_lints {
_ => early_error("multiple input filenames provided")
};
- let sess = build_session(sopts, input_file_path);
+ let sess = build_session(sopts, input_file_path, descriptions);
let cfg = config::build_configuration(&sess);
let odir = matches.opt_str("out-dir").map(|o| Path::new(o));
let ofile = matches.opt_str("o").map(|o| Path::new(o));
}
pub fn early_error(msg: &str) -> ! {
- let mut emitter = diagnostic::EmitterWriter::stderr(diagnostic::Auto);
- emitter.emit(None, msg, diagnostic::Fatal);
+ let mut emitter = diagnostic::EmitterWriter::stderr(diagnostic::Auto, None);
+ emitter.emit(None, msg, None, diagnostic::Fatal);
fail!(diagnostic::FatalError);
}
pub fn early_warn(msg: &str) {
- let mut emitter = diagnostic::EmitterWriter::stderr(diagnostic::Auto);
- emitter.emit(None, msg, diagnostic::Warning);
+ let mut emitter = diagnostic::EmitterWriter::stderr(diagnostic::Auto, None);
+ emitter.emit(None, msg, None, diagnostic::Warning);
}
pub fn list_metadata(sess: &Session, path: &Path,
Err(value) => {
// Task failed without emitting a fatal diagnostic
if !value.is::<diagnostic::FatalError>() {
- let mut emitter = diagnostic::EmitterWriter::stderr(diagnostic::Auto);
+ let mut emitter = diagnostic::EmitterWriter::stderr(diagnostic::Auto, None);
// a .span_bug or .bug call has already printed what
// it wants to print.
emitter.emit(
None,
"unexpected failure",
+ None,
diagnostic::Bug);
}
"run with `RUST_BACKTRACE=1` for a backtrace".to_string(),
];
for note in xs.iter() {
- emitter.emit(None, note.as_slice(), diagnostic::Note)
+ emitter.emit(None, note.as_slice(), None, diagnostic::Note)
}
match r.read_to_string() {
format!("failed to read internal \
stderr: {}",
e).as_slice(),
+ None,
diagnostic::Error)
}
}
use syntax::ast::NodeId;
use syntax::codemap::Span;
use syntax::diagnostic;
+use syntax::diagnostics;
use syntax::parse;
use syntax::parse::token;
use syntax::parse::ParseSess;
pub fn span_err(&self, sp: Span, msg: &str) {
self.diagnostic().span_err(sp, msg)
}
+ pub fn span_err_with_code(&self, sp: Span, msg: &str, code: &str) {
+ self.diagnostic().span_err_with_code(sp, msg, code)
+ }
pub fn err(&self, msg: &str) {
self.diagnostic().handler().err(msg)
}
}
pub fn build_session(sopts: config::Options,
- local_crate_source_file: Option<Path>)
+ local_crate_source_file: Option<Path>,
+ registry: diagnostics::registry::Registry)
-> Session {
let codemap = codemap::CodeMap::new();
let diagnostic_handler =
- diagnostic::default_handler(sopts.color);
+ diagnostic::default_handler(sopts.color, Some(registry));
let span_diagnostic_handler =
diagnostic::mk_span_handler(diagnostic_handler, codemap);
("quad_precision_float", Removed),
+ ("rustc_diagnostic_macros", Active),
+
// A temporary feature gate used to enable parser extensions needed
// to bootstrap fix for #5723.
("issue_5723_bootstrap", Active),
pub default_type_params: Cell<bool>,
pub issue_5723_bootstrap: Cell<bool>,
pub overloaded_calls: Cell<bool>,
+ pub rustc_diagnostic_macros: Cell<bool>
}
impl Features {
default_type_params: Cell::new(false),
issue_5723_bootstrap: Cell::new(false),
overloaded_calls: Cell::new(false),
+ rustc_diagnostic_macros: Cell::new(false)
}
}
}
sess.features.default_type_params.set(cx.has_feature("default_type_params"));
sess.features.issue_5723_bootstrap.set(cx.has_feature("issue_5723_bootstrap"));
sess.features.overloaded_calls.set(cx.has_feature("overloaded_calls"));
+ sess.features.rustc_diagnostic_macros.set(cx.has_feature("rustc_diagnostic_macros"));
}
*/
-#![crate_id = "rustc#0.11.0"] // NOTE: remove after stage0
#![crate_name = "rustc"]
#![experimental]
#![comment = "The Rust compiler"]
#![allow(deprecated)]
#![feature(macro_rules, globs, struct_variant, managed_boxes, quote)]
#![feature(default_type_params, phase, unsafe_destructor)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
+
+#![allow(unknown_features)] // NOTE: Remove after next snapshot
+#![feature(rustc_diagnostic_macros)]
extern crate arena;
extern crate debug;
extern crate graphviz;
extern crate libc;
extern crate serialize;
-extern crate syntax;
extern crate time;
#[phase(plugin, link)] extern crate log;
+#[phase(plugin, link)] extern crate syntax;
+
+mod diagnostics;
pub mod middle {
pub mod def;
pub mod llvmdeps;
}
+__build_diagnostic_array!(DIAGNOSTICS)
+
// A private module so that macro-expanded idents like
// `::rustc::lint::Lint` will also work in `rustc` itself.
//
use std::cmp;
use std::collections::HashMap;
-use std::i16;
-use std::i32;
-use std::i64;
-use std::i8;
-use std::u16;
-use std::u32;
-use std::u64;
-use std::u8;
+use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
use std::gc::Gc;
use syntax::abi;
use syntax::ast_map;
"literal out of range for its type");
}
},
-
+ ty::ty_float(t) => {
+ let (min, max) = float_ty_range(t);
+ let lit_val: f64 = match lit.node {
+ ast::LitFloat(ref v, _) |
+ ast::LitFloatUnsuffixed(ref v) => match from_str(v.get()) {
+ Some(f) => f,
+ None => return
+ },
+ _ => fail!()
+ };
+ if lit_val < min || lit_val > max {
+ cx.span_lint(TYPE_OVERFLOW, e.span,
+ "literal out of range for its type");
+ }
+ },
_ => ()
};
},
}
}
+ fn float_ty_range(float_ty: ast::FloatTy) -> (f64, f64) {
+ match float_ty {
+ ast::TyF32 => (f32::MIN_VALUE as f64, f32::MAX_VALUE as f64),
+ ast::TyF64 => (f64::MIN_VALUE, f64::MAX_VALUE)
+ }
+ }
+
fn check_limits(tcx: &ty::ctxt, binop: ast::BinOp,
l: &ast::Expr, r: &ast::Expr) -> bool {
let (lit, expr, swap) = match (&l.node, &r.node) {
if ast_util::is_local(did) {
match cx.tcx.map.get(did.node) {
ast_map::NodeItem(it) => {
- if attr::contains_name(it.attrs.as_slice(),
- "must_use") {
- cx.span_lint(UNUSED_MUST_USE, s.span,
- "unused result which must be used");
- warned = true;
- }
+ warned |= check_must_use(cx, it.attrs.as_slice(), s.span);
}
_ => {}
}
} else {
csearch::get_item_attrs(&cx.sess().cstore, did, |attrs| {
- if attr::contains_name(attrs.as_slice(), "must_use") {
- cx.span_lint(UNUSED_MUST_USE, s.span,
- "unused result which must be used");
- warned = true;
- }
+ warned |= check_must_use(cx, attrs.as_slice(), s.span);
});
}
}
if !warned {
cx.span_lint(UNUSED_RESULT, s.span, "unused result");
}
+
+ fn check_must_use(cx: &Context, attrs: &[ast::Attribute], sp: Span) -> bool {
+ for attr in attrs.iter() {
+ if attr.check_name("must_use") {
+ let mut msg = "unused result which must be used".to_string();
+ // check for #[must_use="..."]
+ match attr.value_str() {
+ None => {}
+ Some(s) => {
+ msg.push_str(": ");
+ msg.push_str(s.get());
+ }
+ }
+ cx.span_lint(UNUSED_MUST_USE, sp, msg.as_slice());
+ return true;
+ }
+ }
+ false
+ }
}
}
should_match_name: true,
};
let library = match load_ctxt.maybe_load_library_crate() {
- Some (l) => l,
+ Some(l) => l,
None if is_cross => {
// try loading from target crates (only valid if there are
// no syntax extensions)
let registrar = decoder::get_plugin_registrar_fn(library.metadata.as_slice()).map(|id| {
decoder::get_symbol(library.metadata.as_slice(), id)
});
+ if library.dylib.is_none() && registrar.is_some() {
+ let message = format!("plugin crate `{}` only found in rlib format, \
+ but must be available in dylib format",
+ info.ident);
+ self.env.sess.span_err(krate.span, message.as_slice());
+ // No need to abort because the loading code will just ignore this
+ // empty dylib.
+ }
let pc = PluginMetadata {
lib: library.dylib.clone(),
macros: macros,
encode_name(ebml_w, nm);
encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
encode_def_id(ebml_w, local_def(id));
+
+ let stab = stability::lookup(ecx.tcx, field.id);
+ encode_stability(ebml_w, stab);
+
ebml_w.end_tag();
}
index
let v = vec!(*pat);
match is_useful(cx, &seen, v.as_slice(), LeaveOutWitness) {
- NotUseful => cx.tcx.sess.span_err(pat.span, "unreachable pattern"),
+ NotUseful => span_err!(cx.tcx.sess, pat.span, E0001, "unreachable pattern"),
Useful => (),
UsefulWithWitness(_) => unreachable!()
}
pub fn each_node<'a>(&'a self, f: |NodeIndex, &'a Node<N>| -> bool) -> bool {
//! Iterates over all edges defined in the graph.
- self.nodes.iter().enumerate().advance(|(i, node)| f(NodeIndex(i), node))
+ self.nodes.iter().enumerate().all(|(i, node)| f(NodeIndex(i), node))
}
pub fn each_edge<'a>(&'a self, f: |EdgeIndex, &'a Edge<E>| -> bool) -> bool {
//! Iterates over all edges defined in the graph
- self.edges.iter().enumerate().advance(|(i, edge)| f(EdgeIndex(i), edge))
+ self.edges.iter().enumerate().all(|(i, edge)| f(EdgeIndex(i), edge))
}
pub fn each_outgoing_edge<'a>(&'a self,
}
_ => {
let mut method_scope = false;
- self.value_ribs.borrow().iter().rev().advance(|rib| {
+ self.value_ribs.borrow().iter().rev().all(|rib| {
let res = match *rib {
Rib { bindings: _, kind: MethodRibKind(_, _) } => true,
Rib { bindings: _, kind: ItemRibKind } => false,
use util::nodemap::{NodeMap, DefIdMap};
use syntax::codemap::Span;
use syntax::{attr, visit};
+use syntax::ast;
use syntax::ast::{Attribute, Block, Crate, DefId, FnDecl, NodeId, Variant};
use syntax::ast::{Item, Required, Provided, TraitMethod, TypeMethod, Method};
-use syntax::ast::{Generics, StructDef, Ident};
+use syntax::ast::{Generics, StructDef, StructField, Ident};
use syntax::ast_util::is_local;
use syntax::attr::Stability;
use syntax::visit::{FnKind, FkMethod, Visitor};
s.ctor_id.map(|id| self.annotate(id, &[], parent.clone()));
visit::walk_struct_def(self, s, parent)
}
+
+ fn visit_struct_field(&mut self, s: &StructField, parent: Option<Stability>) {
+ let stab = self.annotate(s.node.id, s.node.attrs.as_slice(), parent);
+ visit::walk_struct_field(self, s, stab)
+ }
}
impl Index {
extern_cache: DefIdMap::new()
}
};
- visit::walk_crate(&mut annotator, krate,
- attr::find_stability(krate.attrs.as_slice()));
+ let stab = annotator.annotate(ast::CRATE_NODE_ID, krate.attrs.as_slice(), None);
+ visit::walk_crate(&mut annotator, krate, stab);
annotator.index
}
}
ty::ty_bare_fn(ref fn_ty) => {
match fn_ty.abi.for_target(ccx.sess().targ_cfg.os,
ccx.sess().targ_cfg.arch) {
- Some(Rust) | Some(RustIntrinsic) => {
+ Some(Rust) => {
get_extern_rust_fn(ccx, t, name.as_slice(), did)
}
+ Some(RustIntrinsic) => {
+ ccx.sess().bug("unexpected intrinsic in trans_external_path")
+ }
Some(..) | None => {
foreign::register_foreign_item_fn(ccx, fn_ty.abi, t,
name.as_slice(), None)
-> ValueRef {
match ty::get(node_type).sty {
ty::ty_bare_fn(ref f) => {
- assert!(f.abi == Rust || f.abi == RustIntrinsic);
+ assert!(f.abi == Rust);
}
- _ => fail!("expected bare rust fn or an intrinsic")
+ _ => fail!("expected bare rust fn")
};
let llfn = decl_rust_fn(ccx, node_type, sym.as_slice());
use arena::TypedArena;
use back::abi;
use back::link;
-use driver::session;
use lib::llvm::ValueRef;
use lib::llvm::llvm;
use metadata::csearch;
use middle::trans::glue;
use middle::trans::inline;
use middle::trans::foreign;
+use middle::trans::intrinsic;
use middle::trans::meth;
use middle::trans::monomorphize;
use middle::trans::type_::Type;
use std::gc::Gc;
use syntax::ast;
use synabi = syntax::abi;
-use syntax::ast_map;
pub struct MethodData {
pub llfn: ValueRef,
// value (which is a pair).
Fn(/* llfn */ ValueRef),
+ Intrinsic(ast::NodeId, subst::Substs),
+
TraitMethod(MethodData)
}
fn trans_def<'a>(bcx: &'a Block<'a>, def: def::Def, ref_expr: &ast::Expr)
-> Callee<'a> {
+ debug!("trans_def(def={}, ref_expr={})", def.repr(bcx.tcx()), ref_expr.repr(bcx.tcx()));
+ let expr_ty = node_id_type(bcx, ref_expr.id);
match def {
+ def::DefFn(did, _) if match ty::get(expr_ty).sty {
+ ty::ty_bare_fn(ref f) => f.abi == synabi::RustIntrinsic,
+ _ => false
+ } => {
+ let substs = node_id_substs(bcx, ExprId(ref_expr.id));
+ let def_id = if did.krate != ast::LOCAL_CRATE {
+ inline::maybe_instantiate_inline(bcx.ccx(), did)
+ } else {
+ did
+ };
+ Callee { bcx: bcx, data: Intrinsic(def_id.node, substs) }
+ }
def::DefFn(did, _) |
def::DefStaticMethod(did, def::FromImpl(_), _) => {
fn_callee(bcx, trans_fn_ref(bcx, did, ExprId(ref_expr.id)))
}
};
- // We must monomorphise if the fn has type parameters, is a rust
- // intrinsic, or is a default method. In particular, if we see an
- // intrinsic that is inlined from a different crate, we want to reemit the
- // intrinsic instead of trying to call it in the other crate.
- let must_monomorphise = if !substs.types.is_empty() || is_default {
- true
- } else if def_id.krate == ast::LOCAL_CRATE {
- let map_node = session::expect(
- ccx.sess(),
- tcx.map.find(def_id.node),
- || "local item should be in ast map".to_string());
-
- match map_node {
- ast_map::NodeForeignItem(_) => {
- tcx.map.get_foreign_abi(def_id.node) == synabi::RustIntrinsic
- }
- _ => false
- }
- } else {
- false
- };
+ // We must monomorphise if the fn has type parameters or is a default method.
+ let must_monomorphise = !substs.types.is_empty() || is_default;
// Create a monomorphic version of generic functions
if must_monomorphise {
let callee = get_callee(bcx, cleanup::CustomScope(arg_cleanup_scope));
let mut bcx = callee.bcx;
+ let (abi, ret_ty) = match ty::get(callee_ty).sty {
+ ty::ty_bare_fn(ref f) => (f.abi, f.sig.output),
+ ty::ty_closure(ref f) => (synabi::Rust, f.sig.output),
+ _ => fail!("expected bare rust fn or closure in trans_call_inner")
+ };
+
let (llfn, llenv, llself) = match callee.data {
Fn(llfn) => {
(llfn, None, None)
let llenv = Load(bcx, llenv);
(llfn, Some(llenv), None)
}
- };
+ Intrinsic(node, substs) => {
+ assert!(abi == synabi::RustIntrinsic);
+ assert!(dest.is_some());
- let (abi, ret_ty) = match ty::get(callee_ty).sty {
- ty::ty_bare_fn(ref f) => (f.abi, f.sig.output),
- ty::ty_closure(ref f) => (synabi::Rust, f.sig.output),
- _ => fail!("expected bare rust fn or closure in trans_call_inner")
+ return intrinsic::trans_intrinsic_call(bcx, node, callee_ty,
+ arg_cleanup_scope, args,
+ dest.unwrap(), substs);
+ }
};
- let is_rust_fn = abi == synabi::Rust || abi == synabi::RustIntrinsic;
+
+ // Intrinsics should not become actual functions.
+ // We trans them in place in `trans_intrinsic_call`
+ assert!(abi != synabi::RustIntrinsic);
// Generate a location to store the result. If the user does
// not care about the result, just make a stack slot.
// and done, either the return value of the function will have been
// written in opt_llretslot (if it is Some) or `llresult` will be
// set appropriately (otherwise).
- if is_rust_fn {
+ if abi == synabi::Rust {
let mut llargs = Vec::new();
// Push the out-pointer if we use an out-pointer for this
ArgOverloadedOp(Datum<Expr>, Option<(Datum<Expr>, ast::NodeId)>),
}
-fn trans_args<'a>(cx: &'a Block<'a>,
- args: CallArgs,
- fn_ty: ty::t,
- llargs: &mut Vec<ValueRef> ,
- arg_cleanup_scope: cleanup::ScopeId,
- ignore_self: bool)
- -> &'a Block<'a> {
+pub fn trans_args<'a>(cx: &'a Block<'a>,
+ args: CallArgs,
+ fn_ty: ty::t,
+ llargs: &mut Vec<ValueRef> ,
+ arg_cleanup_scope: cleanup::ScopeId,
+ ignore_self: bool)
+ -> &'a Block<'a> {
let _icx = push_ctxt("trans_args");
let arg_tys = ty::ty_fn_args(fn_ty);
let variadic = ty::fn_is_variadic(fn_ty);
abi.for_target(os, arch).map(|abi| {
match abi {
RustIntrinsic => {
- // Intrinsics are emitted by monomorphic fn
+ // Intrinsics are emitted at the call site
ccx.sess().bug("asked to register intrinsic fn");
}
#![allow(non_uppercase_pattern_statics)]
-use arena::TypedArena;
-use lib::llvm::{SequentiallyConsistent, Acquire, Release, Xchg};
-use lib::llvm::{ValueRef, Pointer, Array, Struct};
+use lib::llvm::{SequentiallyConsistent, Acquire, Release, Xchg, ValueRef};
use lib;
+use middle::subst;
use middle::subst::FnSpace;
use middle::trans::base::*;
use middle::trans::build::*;
+use middle::trans::callee;
+use middle::trans::cleanup;
+use middle::trans::cleanup::CleanupMethods;
use middle::trans::common::*;
use middle::trans::datum::*;
+use middle::trans::expr;
use middle::trans::glue;
use middle::trans::type_of::*;
use middle::trans::type_of;
use middle::trans::type_::Type;
use middle::ty;
use syntax::ast;
-use syntax::ast_map;
use syntax::parse::token;
use util::ppaux::ty_to_string;
Some(ccx.get_intrinsic(&name))
}
-pub fn trans_intrinsic(ccx: &CrateContext,
- decl: ValueRef,
- item: &ast::ForeignItem,
- substs: ¶m_substs,
- ref_id: Option<ast::NodeId>) {
- debug!("trans_intrinsic(item.ident={})", token::get_ident(item.ident));
-
- fn with_overflow_instrinsic(bcx: &Block, name: &'static str, t: ty::t) {
- let first_real_arg = bcx.fcx.arg_pos(0u);
- let a = get_param(bcx.fcx.llfn, first_real_arg);
- let b = get_param(bcx.fcx.llfn, first_real_arg + 1);
- let llfn = bcx.ccx().get_intrinsic(&name);
-
- // convert `i1` to a `bool`, and write to the out parameter
- let val = Call(bcx, llfn, [a, b], []);
- let result = ExtractValue(bcx, val, 0);
- let overflow = ZExt(bcx, ExtractValue(bcx, val, 1), Type::bool(bcx.ccx()));
- let ret = C_undef(type_of::type_of(bcx.ccx(), t));
- let ret = InsertValue(bcx, ret, result, 0);
- let ret = InsertValue(bcx, ret, overflow, 1);
-
- if type_is_immediate(bcx.ccx(), t) {
- Ret(bcx, ret);
- } else {
- let retptr = get_param(bcx.fcx.llfn, bcx.fcx.out_arg_pos());
- Store(bcx, ret, retptr);
- RetVoid(bcx);
+/// Performs late verification that intrinsics are used correctly. At present,
+/// the only intrinsic that needs such verification is `transmute`.
+pub fn check_intrinsics(ccx: &CrateContext) {
+ for transmute_restriction in ccx.tcx
+ .transmute_restrictions
+ .borrow()
+ .iter() {
+ let llfromtype = type_of::sizing_type_of(ccx,
+ transmute_restriction.from);
+ let lltotype = type_of::sizing_type_of(ccx,
+ transmute_restriction.to);
+ let from_type_size = machine::llbitsize_of_real(ccx, llfromtype);
+ let to_type_size = machine::llbitsize_of_real(ccx, lltotype);
+ if from_type_size != to_type_size {
+ ccx.sess()
+ .span_err(transmute_restriction.span,
+ format!("transmute called on types with different sizes: \
+ {} ({} bit{}) to {} ({} bit{})",
+ ty_to_string(ccx.tcx(), transmute_restriction.from),
+ from_type_size as uint,
+ if from_type_size == 1 {
+ ""
+ } else {
+ "s"
+ },
+ ty_to_string(ccx.tcx(), transmute_restriction.to),
+ to_type_size as uint,
+ if to_type_size == 1 {
+ ""
+ } else {
+ "s"
+ }).as_slice());
}
}
+ ccx.sess().abort_if_errors();
+}
- fn volatile_load_intrinsic(bcx: &Block) {
- let first_real_arg = bcx.fcx.arg_pos(0u);
- let src = get_param(bcx.fcx.llfn, first_real_arg);
+pub fn trans_intrinsic_call<'a>(mut bcx: &'a Block<'a>, node: ast::NodeId,
+ callee_ty: ty::t, cleanup_scope: cleanup::CustomScopeIndex,
+ args: callee::CallArgs, dest: expr::Dest,
+ substs: subst::Substs) -> Result<'a> {
- let val = VolatileLoad(bcx, src);
- Ret(bcx, val);
- }
+ let fcx = bcx.fcx;
+ let ccx = fcx.ccx;
+ let tcx = bcx.tcx();
- fn volatile_store_intrinsic(bcx: &Block) {
- let first_real_arg = bcx.fcx.arg_pos(0u);
- let dst = get_param(bcx.fcx.llfn, first_real_arg);
- let val = get_param(bcx.fcx.llfn, first_real_arg + 1);
+ let ret_ty = match ty::get(callee_ty).sty {
+ ty::ty_bare_fn(ref f) => f.sig.output,
+ _ => fail!("expected bare_fn in trans_intrinsic_call")
+ };
+ let llret_ty = type_of::type_of(ccx, ret_ty);
+ let foreign_item = tcx.map.expect_foreign_item(node);
+ let name = token::get_ident(foreign_item.ident);
+
+ // For `transmute` we can just trans the input expr directly into dest
+ if name.get() == "transmute" {
+ match args {
+ callee::ArgExprs(arg_exprs) => {
+ assert_eq!(arg_exprs.len(), 1);
+
+ let (in_type, out_type) = (*substs.types.get(FnSpace, 0),
+ *substs.types.get(FnSpace, 1));
+ let llintype = type_of::type_of(ccx, in_type);
+ let llouttype = type_of::type_of(ccx, out_type);
+
+ let in_type_size = machine::llbitsize_of_real(ccx, llintype);
+ let out_type_size = machine::llbitsize_of_real(ccx, llouttype);
+
+ // This should be caught by the intrinsicck pass
+ assert_eq!(in_type_size, out_type_size);
+
+ // We need to cast the dest so the types work out
+ let dest = match dest {
+ expr::SaveIn(d) => expr::SaveIn(PointerCast(bcx, d, llintype.ptr_to())),
+ expr::Ignore => expr::Ignore
+ };
+ bcx = expr::trans_into(bcx, &*arg_exprs[0], dest);
- VolatileStore(bcx, val, dst);
- RetVoid(bcx);
- }
+ fcx.pop_custom_cleanup_scope(cleanup_scope);
- fn copy_intrinsic(bcx: &Block, allow_overlap: bool, volatile: bool, tp_ty: ty::t) {
- let ccx = bcx.ccx();
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- let align = C_i32(ccx, machine::llalign_of_min(ccx, lltp_ty) as i32);
- let size = machine::llsize_of(ccx, lltp_ty);
- let int_size = machine::llbitsize_of_real(ccx, ccx.int_type);
- let name = if allow_overlap {
- if int_size == 32 {
- "llvm.memmove.p0i8.p0i8.i32"
- } else {
- "llvm.memmove.p0i8.p0i8.i64"
- }
- } else {
- if int_size == 32 {
- "llvm.memcpy.p0i8.p0i8.i32"
- } else {
- "llvm.memcpy.p0i8.p0i8.i64"
- }
- };
-
- let decl = bcx.fcx.llfn;
- let first_real_arg = bcx.fcx.arg_pos(0u);
- let dst_ptr = PointerCast(bcx, get_param(decl, first_real_arg), Type::i8p(ccx));
- let src_ptr = PointerCast(bcx, get_param(decl, first_real_arg + 1), Type::i8p(ccx));
- let count = get_param(decl, first_real_arg + 2);
- let llfn = ccx.get_intrinsic(&name);
- Call(bcx, llfn,
- [dst_ptr, src_ptr, Mul(bcx, size, count), align, C_bool(ccx, volatile)], []);
- RetVoid(bcx);
- }
+ return match dest {
+ expr::SaveIn(d) => Result::new(bcx, d),
+ expr::Ignore => Result::new(bcx, C_undef(llret_ty.ptr_to()))
+ };
- fn memset_intrinsic(bcx: &Block, volatile: bool, tp_ty: ty::t) {
- let ccx = bcx.ccx();
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- let align = C_i32(ccx, machine::llalign_of_min(ccx, lltp_ty) as i32);
- let size = machine::llsize_of(ccx, lltp_ty);
- let name = if machine::llbitsize_of_real(ccx, ccx.int_type) == 32 {
- "llvm.memset.p0i8.i32"
- } else {
- "llvm.memset.p0i8.i64"
- };
-
- let decl = bcx.fcx.llfn;
- let first_real_arg = bcx.fcx.arg_pos(0u);
- let dst_ptr = PointerCast(bcx, get_param(decl, first_real_arg), Type::i8p(ccx));
- let val = get_param(decl, first_real_arg + 1);
- let count = get_param(decl, first_real_arg + 2);
- let llfn = ccx.get_intrinsic(&name);
- Call(bcx, llfn, [dst_ptr, val, Mul(bcx, size, count), align, C_bool(ccx, volatile)], []);
- RetVoid(bcx);
- }
+ }
- fn count_zeros_intrinsic(bcx: &Block, name: &'static str) {
- let x = get_param(bcx.fcx.llfn, bcx.fcx.arg_pos(0u));
- let y = C_bool(bcx.ccx(), false);
- let llfn = bcx.ccx().get_intrinsic(&name);
- let llcall = Call(bcx, llfn, [x, y], []);
- Ret(bcx, llcall);
+ _ => {
+ ccx.sess().bug("expected expr as argument for transmute");
+ }
+ }
}
- let output_type = ty::ty_fn_ret(ty::node_id_to_type(ccx.tcx(), item.id));
-
- let arena = TypedArena::new();
- let fcx = new_fn_ctxt(ccx, decl, item.id, false, output_type,
- substs, Some(item.span), &arena);
- let mut bcx = init_function(&fcx, true, output_type);
-
- set_always_inline(fcx.llfn);
+ // Get location to store the result. If the user does
+ // not care about the result, just make a stack slot
+ let llresult = match dest {
+ expr::SaveIn(d) => d,
+ expr::Ignore => {
+ if !type_is_zero_size(ccx, ret_ty) {
+ alloc_ty(bcx, ret_ty, "intrinsic_result")
+ } else {
+ C_undef(llret_ty.ptr_to())
+ }
+ }
+ };
- let first_real_arg = fcx.arg_pos(0u);
+ // Push the arguments.
+ let mut llargs = Vec::new();
+ bcx = callee::trans_args(bcx, args, callee_ty, &mut llargs,
+ cleanup::CustomScope(cleanup_scope), false);
- let name = token::get_ident(item.ident);
+ fcx.pop_custom_cleanup_scope(cleanup_scope);
- // This requires that atomic intrinsics follow a specific naming pattern:
- // "atomic_<operation>[_<ordering>], and no ordering means SeqCst
- if name.get().starts_with("atomic_") {
- let split: Vec<&str> = name.get().split('_').collect();
- assert!(split.len() >= 2, "Atomic intrinsic not correct format");
- let order = if split.len() == 2 {
- lib::llvm::SequentiallyConsistent
- } else {
- match *split.get(2) {
- "relaxed" => lib::llvm::Monotonic,
- "acq" => lib::llvm::Acquire,
- "rel" => lib::llvm::Release,
- "acqrel" => lib::llvm::AcquireRelease,
- _ => ccx.sess().fatal("unknown ordering in atomic intrinsic")
- }
- };
-
- match *split.get(1) {
- "cxchg" => {
- // See include/llvm/IR/Instructions.h for their implementation
- // of this, I assume that it's good enough for us to use for
- // now.
- let strongest_failure_ordering = match order {
- lib::llvm::NotAtomic | lib::llvm::Unordered =>
- ccx.sess().fatal("cmpxchg must be atomic"),
- lib::llvm::Monotonic | lib::llvm::Release =>
- lib::llvm::Monotonic,
- lib::llvm::Acquire | lib::llvm::AcquireRelease =>
- lib::llvm::Acquire,
- lib::llvm::SequentiallyConsistent =>
- lib::llvm::SequentiallyConsistent,
- };
- let res = AtomicCmpXchg(bcx, get_param(decl, first_real_arg),
- get_param(decl, first_real_arg + 1u),
- get_param(decl, first_real_arg + 2u),
- order, strongest_failure_ordering);
- if unsafe { lib::llvm::llvm::LLVMVersionMinor() >= 5 } {
- Ret(bcx, ExtractValue(bcx, res, 0));
- } else {
- Ret(bcx, res);
- }
- }
- "load" => {
- let old = AtomicLoad(bcx, get_param(decl, first_real_arg),
- order);
- Ret(bcx, old);
- }
- "store" => {
- AtomicStore(bcx, get_param(decl, first_real_arg + 1u),
- get_param(decl, first_real_arg),
- order);
- RetVoid(bcx);
- }
- "fence" => {
- AtomicFence(bcx, order);
- RetVoid(bcx);
- }
- op => {
- // These are all AtomicRMW ops
- let atom_op = match op {
- "xchg" => lib::llvm::Xchg,
- "xadd" => lib::llvm::Add,
- "xsub" => lib::llvm::Sub,
- "and" => lib::llvm::And,
- "nand" => lib::llvm::Nand,
- "or" => lib::llvm::Or,
- "xor" => lib::llvm::Xor,
- "max" => lib::llvm::Max,
- "min" => lib::llvm::Min,
- "umax" => lib::llvm::UMax,
- "umin" => lib::llvm::UMin,
- _ => ccx.sess().fatal("unknown atomic operation")
- };
+ let simple = get_simple_intrinsic(ccx, &*foreign_item);
- let old = AtomicRMW(bcx, atom_op, get_param(decl, first_real_arg),
- get_param(decl, first_real_arg + 1u),
- order);
- Ret(bcx, old);
- }
+ let llval = match (simple, name.get()) {
+ (Some(llfn), _) => {
+ Call(bcx, llfn, llargs.as_slice(), [])
}
-
- fcx.cleanup();
- return;
- }
-
- match name.get() {
- "abort" => {
- let llfn = bcx.ccx().get_intrinsic(&("llvm.trap"));
- Call(bcx, llfn, [], []);
+ (_, "abort") => {
+ let llfn = ccx.get_intrinsic(&("llvm.trap"));
+ let v = Call(bcx, llfn, [], []);
Unreachable(bcx);
+ v
}
- "breakpoint" => {
- let llfn = bcx.ccx().get_intrinsic(&("llvm.debugtrap"));
- Call(bcx, llfn, [], []);
- RetVoid(bcx);
+ (_, "breakpoint") => {
+ let llfn = ccx.get_intrinsic(&("llvm.debugtrap"));
+ Call(bcx, llfn, [], [])
}
- "size_of" => {
- let tp_ty = *substs.substs.types.get(FnSpace, 0);
+ (_, "size_of") => {
+ let tp_ty = *substs.types.get(FnSpace, 0);
let lltp_ty = type_of::type_of(ccx, tp_ty);
- Ret(bcx, C_uint(ccx, machine::llsize_of_real(ccx, lltp_ty) as uint));
+ C_uint(ccx, machine::llsize_of_real(ccx, lltp_ty) as uint)
}
- "move_val_init" => {
+ (_, "min_align_of") => {
+ let tp_ty = *substs.types.get(FnSpace, 0);
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ C_uint(ccx, machine::llalign_of_min(ccx, lltp_ty) as uint)
+ }
+ (_, "pref_align_of") => {
+ let tp_ty = *substs.types.get(FnSpace, 0);
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ C_uint(ccx, machine::llalign_of_pref(ccx, lltp_ty) as uint)
+ }
+ (_, "move_val_init") => {
// Create a datum reflecting the value being moved.
// Use `appropriate_mode` so that the datum is by ref
// if the value is non-immediate. Note that, with
// intrinsics, there are no argument cleanups to
// concern ourselves with, so we can use an rvalue datum.
- let tp_ty = *substs.substs.types.get(FnSpace, 0);
+ let tp_ty = *substs.types.get(FnSpace, 0);
let mode = appropriate_rvalue_mode(ccx, tp_ty);
- let src = Datum {val: get_param(decl, first_real_arg + 1u),
- ty: tp_ty,
- kind: Rvalue::new(mode)};
- bcx = src.store_to(bcx, get_param(decl, first_real_arg));
- RetVoid(bcx);
- }
- "min_align_of" => {
- let tp_ty = *substs.substs.types.get(FnSpace, 0);
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- Ret(bcx, C_uint(ccx, machine::llalign_of_min(ccx, lltp_ty) as uint));
- }
- "pref_align_of"=> {
- let tp_ty = *substs.substs.types.get(FnSpace, 0);
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- Ret(bcx, C_uint(ccx, machine::llalign_of_pref(ccx, lltp_ty) as uint));
+ let src = Datum {
+ val: *llargs.get(1),
+ ty: tp_ty,
+ kind: Rvalue::new(mode)
+ };
+ bcx = src.store_to(bcx, *llargs.get(0));
+ C_nil(ccx)
}
- "get_tydesc" => {
- let tp_ty = *substs.substs.types.get(FnSpace, 0);
+ (_, "get_tydesc") => {
+ let tp_ty = *substs.types.get(FnSpace, 0);
let static_ti = get_tydesc(ccx, tp_ty);
glue::lazily_emit_visit_glue(ccx, &*static_ti);
// but there's a circularity between translating rust types to llvm
// types and having a tydesc type available. So I can't directly access
// the llvm type of intrinsic::TyDesc struct.
- let userland_tydesc_ty = type_of::type_of(ccx, output_type);
- let td = PointerCast(bcx, static_ti.tydesc, userland_tydesc_ty);
- Ret(bcx, td);
+ PointerCast(bcx, static_ti.tydesc, llret_ty)
}
- "type_id" => {
+ (_, "type_id") => {
let hash = ty::hash_crate_independent(
ccx.tcx(),
- *substs.substs.types.get(FnSpace, 0),
+ *substs.types.get(FnSpace, 0),
&ccx.link_meta.crate_hash);
// NB: This needs to be kept in lockstep with the TypeId struct in
- // libstd/unstable/intrinsics.rs
- let val = C_named_struct(type_of::type_of(ccx, output_type),
- [C_u64(ccx, hash)]);
- match bcx.fcx.llretptr.get() {
- Some(ptr) => {
- Store(bcx, val, ptr);
- RetVoid(bcx);
- },
- None => Ret(bcx, val)
- }
+ // the intrinsic module
+ C_named_struct(llret_ty, [C_u64(ccx, hash)])
}
- "init" => {
- let tp_ty = *substs.substs.types.get(FnSpace, 0);
+ (_, "init") => {
+ let tp_ty = *substs.types.get(FnSpace, 0);
let lltp_ty = type_of::type_of(ccx, tp_ty);
- match bcx.fcx.llretptr.get() {
- Some(ptr) => { Store(bcx, C_null(lltp_ty), ptr); RetVoid(bcx); }
- None if ty::type_is_nil(tp_ty) => RetVoid(bcx),
- None => Ret(bcx, C_null(lltp_ty)),
- }
- }
- "uninit" => {
- // Do nothing, this is effectively a no-op
- let retty = *substs.substs.types.get(FnSpace, 0);
- if type_is_immediate(ccx, retty) && !return_type_is_void(ccx, retty) {
- unsafe {
- Ret(bcx, lib::llvm::llvm::LLVMGetUndef(arg_type_of(ccx, retty).to_ref()));
- }
+ if return_type_is_void(ccx, tp_ty) {
+ C_nil(ccx)
} else {
- RetVoid(bcx)
+ C_null(lltp_ty)
}
}
- "forget" => {
- RetVoid(bcx);
+ // Effectively no-ops
+ (_, "uninit") | (_, "forget") => {
+ C_nil(ccx)
}
- "transmute" => {
- let (in_type, out_type) = (*substs.substs.types.get(FnSpace, 0),
- *substs.substs.types.get(FnSpace, 1));
- let llintype = type_of::type_of(ccx, in_type);
- let llouttype = type_of::type_of(ccx, out_type);
-
- let in_type_size = machine::llbitsize_of_real(ccx, llintype);
- let out_type_size = machine::llbitsize_of_real(ccx, llouttype);
- if in_type_size != out_type_size {
- let sp = match ccx.tcx.map.get(ref_id.unwrap()) {
- ast_map::NodeExpr(e) => e.span,
- _ => fail!("transmute has non-expr arg"),
- };
- ccx.sess().span_bug(sp,
- format!("transmute called on types with different sizes: \
- {} ({} bit{}) to \
- {} ({} bit{})",
- ty_to_string(ccx.tcx(), in_type),
- in_type_size,
- if in_type_size == 1 {""} else {"s"},
- ty_to_string(ccx.tcx(), out_type),
- out_type_size,
- if out_type_size == 1 {""} else {"s"}).as_slice());
- }
-
- if !return_type_is_void(ccx, out_type) {
- let llsrcval = get_param(decl, first_real_arg);
- if type_is_immediate(ccx, in_type) {
- match fcx.llretptr.get() {
- Some(llretptr) => {
- Store(bcx, llsrcval, PointerCast(bcx, llretptr, llintype.ptr_to()));
- RetVoid(bcx);
- }
- None => match (llintype.kind(), llouttype.kind()) {
- (Pointer, other) | (other, Pointer) if other != Pointer => {
- let tmp = Alloca(bcx, llouttype, "");
- Store(bcx, llsrcval, PointerCast(bcx, tmp, llintype.ptr_to()));
- Ret(bcx, Load(bcx, tmp));
- }
- (Array, _) | (_, Array) | (Struct, _) | (_, Struct) => {
- let tmp = Alloca(bcx, llouttype, "");
- Store(bcx, llsrcval, PointerCast(bcx, tmp, llintype.ptr_to()));
- Ret(bcx, Load(bcx, tmp));
- }
- _ => {
- let llbitcast = BitCast(bcx, llsrcval, llouttype);
- Ret(bcx, llbitcast)
- }
- }
- }
- } else if type_is_immediate(ccx, out_type) {
- let llsrcptr = PointerCast(bcx, llsrcval, llouttype.ptr_to());
- let ll_load = Load(bcx, llsrcptr);
- Ret(bcx, ll_load);
- } else {
- // NB: Do not use a Load and Store here. This causes massive
- // code bloat when `transmute` is used on large structural
- // types.
- let lldestptr = fcx.llretptr.get().unwrap();
- let lldestptr = PointerCast(bcx, lldestptr, Type::i8p(ccx));
- let llsrcptr = PointerCast(bcx, llsrcval, Type::i8p(ccx));
-
- let llsize = llsize_of(ccx, llintype);
- call_memcpy(bcx, lldestptr, llsrcptr, llsize, 1);
- RetVoid(bcx);
- };
- } else {
- RetVoid(bcx);
- }
+ (_, "needs_drop") => {
+ let tp_ty = *substs.types.get(FnSpace, 0);
+ C_bool(ccx, ty::type_needs_drop(ccx.tcx(), tp_ty))
}
- "needs_drop" => {
- let tp_ty = *substs.substs.types.get(FnSpace, 0);
- Ret(bcx, C_bool(ccx, ty::type_needs_drop(ccx.tcx(), tp_ty)));
+ (_, "owns_managed") => {
+ let tp_ty = *substs.types.get(FnSpace, 0);
+ C_bool(ccx, ty::type_contents(ccx.tcx(), tp_ty).owns_managed())
}
- "owns_managed" => {
- let tp_ty = *substs.substs.types.get(FnSpace, 0);
- Ret(bcx, C_bool(ccx, ty::type_contents(ccx.tcx(), tp_ty).owns_managed()));
- }
- "visit_tydesc" => {
- let td = get_param(decl, first_real_arg);
- let visitor = get_param(decl, first_real_arg + 1u);
+ (_, "visit_tydesc") => {
+ let td = *llargs.get(0);
+ let visitor = *llargs.get(1);
let td = PointerCast(bcx, td, ccx.tydesc_type().ptr_to());
glue::call_visit_glue(bcx, visitor, td, None);
- RetVoid(bcx);
+ C_nil(ccx)
}
- "offset" => {
- let ptr = get_param(decl, first_real_arg);
- let offset = get_param(decl, first_real_arg + 1);
- let lladdr = InBoundsGEP(bcx, ptr, [offset]);
- Ret(bcx, lladdr);
+ (_, "offset") => {
+ let ptr = *llargs.get(0);
+ let offset = *llargs.get(1);
+ InBoundsGEP(bcx, ptr, [offset])
}
- "copy_nonoverlapping_memory" => {
- copy_intrinsic(bcx, false, false, *substs.substs.types.get(FnSpace, 0))
+
+ (_, "copy_nonoverlapping_memory") => {
+ copy_intrinsic(bcx, false, false, *substs.types.get(FnSpace, 0),
+ *llargs.get(0), *llargs.get(1), *llargs.get(2))
}
- "copy_memory" => {
- copy_intrinsic(bcx, true, false, *substs.substs.types.get(FnSpace, 0))
+ (_, "copy_memory") => {
+ copy_intrinsic(bcx, true, false, *substs.types.get(FnSpace, 0),
+ *llargs.get(0), *llargs.get(1), *llargs.get(2))
}
- "set_memory" => {
- memset_intrinsic(bcx, false, *substs.substs.types.get(FnSpace, 0))
+ (_, "set_memory") => {
+ memset_intrinsic(bcx, false, *substs.types.get(FnSpace, 0),
+ *llargs.get(0), *llargs.get(1), *llargs.get(2))
}
- "volatile_copy_nonoverlapping_memory" => {
- copy_intrinsic(bcx, false, true, *substs.substs.types.get(FnSpace, 0))
+ (_, "volatile_copy_nonoverlapping_memory") => {
+ copy_intrinsic(bcx, false, true, *substs.types.get(FnSpace, 0),
+ *llargs.get(0), *llargs.get(1), *llargs.get(2))
}
-
- "volatile_copy_memory" => {
- copy_intrinsic(bcx, true, true, *substs.substs.types.get(FnSpace, 0))
+ (_, "volatile_copy_memory") => {
+ copy_intrinsic(bcx, true, true, *substs.types.get(FnSpace, 0),
+ *llargs.get(0), *llargs.get(1), *llargs.get(2))
+ }
+ (_, "volatile_set_memory") => {
+ memset_intrinsic(bcx, true, *substs.types.get(FnSpace, 0),
+ *llargs.get(0), *llargs.get(1), *llargs.get(2))
}
+ (_, "volatile_load") => {
+ VolatileLoad(bcx, *llargs.get(0))
+ },
+ (_, "volatile_store") => {
+ VolatileStore(bcx, *llargs.get(1), *llargs.get(0));
+ C_nil(ccx)
+ },
+
+ (_, "ctlz8") => count_zeros_intrinsic(bcx, "llvm.ctlz.i8", *llargs.get(0)),
+ (_, "ctlz16") => count_zeros_intrinsic(bcx, "llvm.ctlz.i16", *llargs.get(0)),
+ (_, "ctlz32") => count_zeros_intrinsic(bcx, "llvm.ctlz.i32", *llargs.get(0)),
+ (_, "ctlz64") => count_zeros_intrinsic(bcx, "llvm.ctlz.i64", *llargs.get(0)),
+ (_, "cttz8") => count_zeros_intrinsic(bcx, "llvm.cttz.i8", *llargs.get(0)),
+ (_, "cttz16") => count_zeros_intrinsic(bcx, "llvm.cttz.i16", *llargs.get(0)),
+ (_, "cttz32") => count_zeros_intrinsic(bcx, "llvm.cttz.i32", *llargs.get(0)),
+ (_, "cttz64") => count_zeros_intrinsic(bcx, "llvm.cttz.i64", *llargs.get(0)),
+
+ (_, "i8_add_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.sadd.with.overflow.i8", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "i16_add_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.sadd.with.overflow.i16", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "i32_add_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.sadd.with.overflow.i32", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "i64_add_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.sadd.with.overflow.i64", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+
+ (_, "u8_add_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.uadd.with.overflow.i8", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "u16_add_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.uadd.with.overflow.i16", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "u32_add_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.uadd.with.overflow.i32", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "u64_add_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.uadd.with.overflow.i64", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+
+ (_, "i8_sub_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.ssub.with.overflow.i8", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "i16_sub_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.ssub.with.overflow.i16", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "i32_sub_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.ssub.with.overflow.i32", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "i64_sub_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.ssub.with.overflow.i64", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+
+ (_, "u8_sub_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.usub.with.overflow.i8", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "u16_sub_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.usub.with.overflow.i16", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "u32_sub_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.usub.with.overflow.i32", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "u64_sub_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.usub.with.overflow.i64", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+
+ (_, "i8_mul_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.smul.with.overflow.i8", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "i16_mul_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.smul.with.overflow.i16", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "i32_mul_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.smul.with.overflow.i32", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "i64_mul_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.smul.with.overflow.i64", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+
+ (_, "u8_mul_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.umul.with.overflow.i8", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "u16_mul_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.umul.with.overflow.i16", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "u32_mul_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.umul.with.overflow.i32", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+ (_, "u64_mul_with_overflow") =>
+ with_overflow_intrinsic(bcx, "llvm.umul.with.overflow.i64", ret_ty,
+ *llargs.get(0), *llargs.get(1)),
+
+ // This requires that atomic intrinsics follow a specific naming pattern:
+ // "atomic_<operation>[_<ordering>]", and no ordering means SeqCst
+ (_, name) if name.starts_with("atomic_") => {
+ let split: Vec<&str> = name.split('_').collect();
+ assert!(split.len() >= 2, "Atomic intrinsic not correct format");
+
+ let order = if split.len() == 2 {
+ lib::llvm::SequentiallyConsistent
+ } else {
+ match *split.get(2) {
+ "relaxed" => lib::llvm::Monotonic,
+ "acq" => lib::llvm::Acquire,
+ "rel" => lib::llvm::Release,
+ "acqrel" => lib::llvm::AcquireRelease,
+ _ => ccx.sess().fatal("unknown ordering in atomic intrinsic")
+ }
+ };
+
+ match *split.get(1) {
+ "cxchg" => {
+ // See include/llvm/IR/Instructions.h for their implementation
+ // of this, I assume that it's good enough for us to use for
+ // now.
+ let strongest_failure_ordering = match order {
+ lib::llvm::NotAtomic | lib::llvm::Unordered =>
+ ccx.sess().fatal("cmpxchg must be atomic"),
+
+ lib::llvm::Monotonic | lib::llvm::Release =>
+ lib::llvm::Monotonic,
+
+ lib::llvm::Acquire | lib::llvm::AcquireRelease =>
+ lib::llvm::Acquire,
+
+ lib::llvm::SequentiallyConsistent =>
+ lib::llvm::SequentiallyConsistent
+ };
+
+ let res = AtomicCmpXchg(bcx, *llargs.get(0), *llargs.get(1),
+ *llargs.get(2), order,
+ strongest_failure_ordering);
+ if unsafe { lib::llvm::llvm::LLVMVersionMinor() >= 5 } {
+ ExtractValue(bcx, res, 0)
+ } else {
+ res
+ }
+ }
+
+ "load" => {
+ AtomicLoad(bcx, *llargs.get(0), order)
+ }
+ "store" => {
+ AtomicStore(bcx, *llargs.get(1), *llargs.get(0), order);
+ C_nil(ccx)
+ }
+
+ "fence" => {
+ AtomicFence(bcx, order);
+ C_nil(ccx)
+ }
+
+ // These are all AtomicRMW ops
+ op => {
+ let atom_op = match op {
+ "xchg" => lib::llvm::Xchg,
+ "xadd" => lib::llvm::Add,
+ "xsub" => lib::llvm::Sub,
+ "and" => lib::llvm::And,
+ "nand" => lib::llvm::Nand,
+ "or" => lib::llvm::Or,
+ "xor" => lib::llvm::Xor,
+ "max" => lib::llvm::Max,
+ "min" => lib::llvm::Min,
+ "umax" => lib::llvm::UMax,
+ "umin" => lib::llvm::UMin,
+ _ => ccx.sess().fatal("unknown atomic operation")
+ };
+
+ AtomicRMW(bcx, atom_op, *llargs.get(0), *llargs.get(1), order)
+ }
+ }
- "volatile_set_memory" => {
- memset_intrinsic(bcx, true, *substs.substs.types.get(FnSpace, 0))
}
- "ctlz8" => count_zeros_intrinsic(bcx, "llvm.ctlz.i8"),
- "ctlz16" => count_zeros_intrinsic(bcx, "llvm.ctlz.i16"),
- "ctlz32" => count_zeros_intrinsic(bcx, "llvm.ctlz.i32"),
- "ctlz64" => count_zeros_intrinsic(bcx, "llvm.ctlz.i64"),
- "cttz8" => count_zeros_intrinsic(bcx, "llvm.cttz.i8"),
- "cttz16" => count_zeros_intrinsic(bcx, "llvm.cttz.i16"),
- "cttz32" => count_zeros_intrinsic(bcx, "llvm.cttz.i32"),
- "cttz64" => count_zeros_intrinsic(bcx, "llvm.cttz.i64"),
-
- "volatile_load" => volatile_load_intrinsic(bcx),
- "volatile_store" => volatile_store_intrinsic(bcx),
-
- "i8_add_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i8", output_type),
- "i16_add_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i16", output_type),
- "i32_add_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i32", output_type),
- "i64_add_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i64", output_type),
-
- "u8_add_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i8", output_type),
- "u16_add_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i16", output_type),
- "u32_add_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i32", output_type),
- "u64_add_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i64", output_type),
-
- "i8_sub_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i8", output_type),
- "i16_sub_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i16", output_type),
- "i32_sub_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i32", output_type),
- "i64_sub_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i64", output_type),
-
- "u8_sub_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i8", output_type),
- "u16_sub_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i16", output_type),
- "u32_sub_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i32", output_type),
- "u64_sub_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i64", output_type),
-
- "i8_mul_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i8", output_type),
- "i16_mul_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i16", output_type),
- "i32_mul_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i32", output_type),
- "i64_mul_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i64", output_type),
-
- "u8_mul_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i8", output_type),
- "u16_mul_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i16", output_type),
- "u32_mul_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i32", output_type),
- "u64_mul_with_overflow" =>
- with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i64", output_type),
-
- _ => {
- // Could we make this an enum rather than a string? does it get
- // checked earlier?
- ccx.sess().span_bug(item.span, "unknown intrinsic");
+ (_, _) => ccx.sess().span_bug(foreign_item.span, "unknown intrinsic")
+ };
+
+ if val_ty(llval) != Type::void(ccx) &&
+ machine::llsize_of_alloc(ccx, val_ty(llval)) != 0 {
+ store_ty(bcx, llval, llresult, ret_ty);
+ }
+
+ // If we made a temporary stack slot, let's clean it up
+ match dest {
+ expr::Ignore => {
+ bcx = glue::drop_ty(bcx, llresult, ret_ty);
}
+ expr::SaveIn(_) => {}
}
- fcx.cleanup();
+
+ Result::new(bcx, llresult)
}
-/// Performs late verification that intrinsics are used correctly. At present,
-/// the only intrinsic that needs such verification is `transmute`.
-pub fn check_intrinsics(ccx: &CrateContext) {
- for transmute_restriction in ccx.tcx
- .transmute_restrictions
- .borrow()
- .iter() {
- let llfromtype = type_of::sizing_type_of(ccx,
- transmute_restriction.from);
- let lltotype = type_of::sizing_type_of(ccx,
- transmute_restriction.to);
- let from_type_size = machine::llbitsize_of_real(ccx, llfromtype);
- let to_type_size = machine::llbitsize_of_real(ccx, lltotype);
- if from_type_size != to_type_size {
- ccx.sess()
- .span_err(transmute_restriction.span,
- format!("transmute called on types with different sizes: \
- {} ({} bit{}) to {} ({} bit{})",
- ty_to_string(ccx.tcx(), transmute_restriction.from),
- from_type_size as uint,
- if from_type_size == 1 {
- ""
- } else {
- "s"
- },
- ty_to_string(ccx.tcx(), transmute_restriction.to),
- to_type_size as uint,
- if to_type_size == 1 {
- ""
- } else {
- "s"
- }).as_slice());
+fn copy_intrinsic(bcx: &Block, allow_overlap: bool, volatile: bool,
+ tp_ty: ty::t, dst: ValueRef, src: ValueRef, count: ValueRef) -> ValueRef {
+ let ccx = bcx.ccx();
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ let align = C_i32(ccx, machine::llalign_of_min(ccx, lltp_ty) as i32);
+ let size = machine::llsize_of(ccx, lltp_ty);
+ let int_size = machine::llbitsize_of_real(ccx, ccx.int_type);
+ let name = if allow_overlap {
+ if int_size == 32 {
+ "llvm.memmove.p0i8.p0i8.i32"
+ } else {
+ "llvm.memmove.p0i8.p0i8.i64"
}
- }
- ccx.sess().abort_if_errors();
+ } else {
+ if int_size == 32 {
+ "llvm.memcpy.p0i8.p0i8.i32"
+ } else {
+ "llvm.memcpy.p0i8.p0i8.i64"
+ }
+ };
+
+ let dst_ptr = PointerCast(bcx, dst, Type::i8p(ccx));
+ let src_ptr = PointerCast(bcx, src, Type::i8p(ccx));
+ let llfn = ccx.get_intrinsic(&name);
+
+ Call(bcx, llfn, [dst_ptr, src_ptr, Mul(bcx, size, count), align,
+ C_bool(ccx, volatile)], [])
}
+fn memset_intrinsic(bcx: &Block, volatile: bool, tp_ty: ty::t,
+ dst: ValueRef, val: ValueRef, count: ValueRef) -> ValueRef {
+ let ccx = bcx.ccx();
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ let align = C_i32(ccx, machine::llalign_of_min(ccx, lltp_ty) as i32);
+ let size = machine::llsize_of(ccx, lltp_ty);
+ let name = if machine::llbitsize_of_real(ccx, ccx.int_type) == 32 {
+ "llvm.memset.p0i8.i32"
+ } else {
+ "llvm.memset.p0i8.i64"
+ };
+
+ let dst_ptr = PointerCast(bcx, dst, Type::i8p(ccx));
+ let llfn = ccx.get_intrinsic(&name);
+
+ Call(bcx, llfn, [dst_ptr, val, Mul(bcx, size, count), align,
+ C_bool(ccx, volatile)], [])
+}
+
+fn count_zeros_intrinsic(bcx: &Block, name: &'static str, val: ValueRef) -> ValueRef {
+ let y = C_bool(bcx.ccx(), false);
+ let llfn = bcx.ccx().get_intrinsic(&name);
+ Call(bcx, llfn, [val, y], [])
+}
+
+fn with_overflow_intrinsic(bcx: &Block, name: &'static str, t: ty::t,
+ a: ValueRef, b: ValueRef) -> ValueRef {
+ let llfn = bcx.ccx().get_intrinsic(&name);
+
+ // Convert `i1` to a `bool`, and write it to the out parameter
+ let val = Call(bcx, llfn, [a, b], []);
+ let result = ExtractValue(bcx, val, 0);
+ let overflow = ZExt(bcx, ExtractValue(bcx, val, 1), Type::bool(bcx.ccx()));
+ let ret = C_undef(type_of::type_of(bcx.ccx(), t));
+ let ret = InsertValue(bcx, ret, result, 0);
+ let ret = InsertValue(bcx, ret, overflow, 1);
+
+ ret
+}
use middle::trans::base::{trans_fn, decl_internal_rust_fn};
use middle::trans::base;
use middle::trans::common::*;
-use middle::trans::intrinsic;
use middle::ty;
use middle::typeck;
use util::ppaux::Repr;
}
}
}
- ast_map::NodeForeignItem(i) => {
- let simple = intrinsic::get_simple_intrinsic(ccx, &*i);
- match simple {
- Some(decl) => decl,
- None => {
- let d = mk_lldecl();
- intrinsic::trans_intrinsic(ccx, d, &*i, &psubsts, ref_id);
- d
- }
- }
- }
ast_map::NodeVariant(v) => {
let parent = ccx.tcx.map.get_parent(fn_id.node);
let tvs = ty::enum_variants(ccx.tcx(), local_def(parent));
}
// Ugh -- but this ensures any new variants won't be forgotten
+ ast_map::NodeForeignItem(..) |
ast_map::NodeLifetime(..) |
ast_map::NodeExpr(..) |
ast_map::NodeStmt(..) |
type_of_rust_fn(cx, true, f.sig.inputs.as_slice(), f.sig.output)
}
ty::ty_bare_fn(ref f) => {
- if f.abi == abi::Rust || f.abi == abi::RustIntrinsic {
+ if f.abi == abi::Rust {
type_of_rust_fn(cx,
false,
f.sig.inputs.as_slice(),
f.sig.output)
+ } else if f.abi == abi::RustIntrinsic {
+ cx.sess().bug("type_of_fn_from_ty given intrinsic")
} else {
foreign::lltype_for_foreign_fn(cx, fty)
}
pub fn each_attr(tcx: &ctxt, did: DefId, f: |&ast::Attribute| -> bool) -> bool {
if is_local(did) {
let item = tcx.map.expect_item(did.node);
- item.attrs.iter().advance(|attr| f(attr))
+ item.attrs.iter().all(|attr| f(attr))
} else {
info!("getting foreign attrs");
let mut cont = true;
csearch::get_item_attrs(&tcx.sess.cstore, did, |attrs| {
if cont {
- cont = attrs.iter().advance(|attr| f(attr));
+ cont = attrs.iter().all(|attr| f(attr));
}
});
info!("done");
actual,
fcx.infcx().ty_to_string(t_1))
}, t_e, None);
+ } else if ty::type_is_unsafe_ptr(t_e) && t_1_is_float {
+ fcx.type_error_message(span, |actual| {
+ format!("cannot cast from pointer to float directly: `{}` as `{}`; cast through an \
+ integer first",
+ actual,
+ fcx.infcx().ty_to_string(t_1))
+ }, t_e, None);
}
fcx.write_ty(id, t_1);
fn emit(&mut self,
_cmsp: Option<(&codemap::CodeMap, Span)>,
msg: &str,
+ _: Option<&str>,
lvl: Level)
{
remove_message(self, msg, lvl);
* `#[plugin_registrar]` function:
*
* ```rust,ignore
- * #![crate_id = "myplugin"]
+ * #![crate_name = "myplugin"]
* #![crate_type = "dylib"]
* #![feature(plugin_registrar)]
*
format!("{}{}", mutability_to_string(m.mutbl), ty_to_string(cx, m.ty))
}
-#[cfg(stage0)]
-pub fn trait_store_to_str(cx: &ctxt, s: ty::TraitStore) -> String {
- trait_store_to_string(cx, s)
-}
-
pub fn trait_store_to_string(cx: &ctxt, s: ty::TraitStore) -> String {
match s {
ty::UniqTraitStore => "Box ".to_string(),
trait_ref.user_string(cx).to_string()
}
-#[cfg(stage0)]
-pub fn ty_to_str(cx: &ctxt, typ: t) -> String {
- ty_to_string(cx, typ)
-}
-
pub fn ty_to_string(cx: &ctxt, typ: t) -> String {
fn fn_input_to_string(cx: &ctxt, input: ty::t) -> String {
ty_to_string(cx, input).to_string()
name: Some(name.clean()),
attrs: Vec::new(),
visibility: Some(ast::Public),
- stability: get_stability(self.id),
// FIXME: this is not accurate, we need an id for
// the specific field but we're using the id
- // for the whole variant. Nothing currently
- // uses this so we should be good for now.
+ // for the whole variant. Thus we read the
+ // stability from the whole variant as well.
+ // Struct variants are experimental and need
+ // more infrastructure work before we can get
+ // at the needed information here.
def_id: self.id,
+ stability: get_stability(self.id),
inner: StructFieldItem(
TypedStructField(ty.clean())
)
visibility: Some(ast::Public),
def_id: self.id,
inner: VariantItem(Variant { kind: kind }),
- stability: None,
+ stability: get_stability(self.id),
}
}
}
source: self.span.clean(),
def_id: ast_util::local_def(self.id),
visibility: self.vis.clean(),
- stability: None,
+ stability: get_stability(ast_util::local_def(self.id)),
inner: inner,
}
}
let codemap = syntax::codemap::CodeMap::new();
- let diagnostic_handler = syntax::diagnostic::default_handler(syntax::diagnostic::Auto);
+ let diagnostic_handler = syntax::diagnostic::default_handler(syntax::diagnostic::Auto, None);
let span_diagnostic_handler =
syntax::diagnostic::mk_span_handler(diagnostic_handler, codemap);
use syntax::ast_util;
use clean;
+use stability_summary::ModuleSummary;
use html::item_type;
use html::item_type::ItemType;
use html::render;
}
}
}
+
+impl fmt::Show for ModuleSummary {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fn fmt_inner<'a>(f: &mut fmt::Formatter,
+ context: &mut Vec<&'a str>,
+ m: &'a ModuleSummary)
+ -> fmt::Result {
+ let cnt = m.counts;
+ let tot = cnt.total();
+ if tot == 0 { return Ok(()) }
+
+ context.push(m.name.as_slice());
+ let path = context.connect("::");
+
+ // the total width of each row's stability summary, in pixels
+ let width = 500;
+
+ try!(write!(f, "<tr>"));
+ try!(write!(f, "<td class='summary'>\
+ <a class='summary' href='{}'>{}</a></td>",
+ Vec::from_slice(context.slice_from(1))
+ .append_one("index.html").connect("/"),
+ path));
+ try!(write!(f, "<td>"));
+ try!(write!(f, "<span class='summary Stable' \
+ style='width: {}px; display: inline-block'> </span>",
+ (width * cnt.stable)/tot));
+ try!(write!(f, "<span class='summary Unstable' \
+ style='width: {}px; display: inline-block'> </span>",
+ (width * cnt.unstable)/tot));
+ try!(write!(f, "<span class='summary Experimental' \
+ style='width: {}px; display: inline-block'> </span>",
+ (width * cnt.experimental)/tot));
+ try!(write!(f, "<span class='summary Deprecated' \
+ style='width: {}px; display: inline-block'> </span>",
+ (width * cnt.deprecated)/tot));
+ try!(write!(f, "<span class='summary Unmarked' \
+ style='width: {}px; display: inline-block'> </span>",
+ (width * cnt.unmarked)/tot));
+ try!(write!(f, "</td></tr>"));
+
+ for submodule in m.submodules.iter() {
+ try!(fmt_inner(f, context, submodule));
+ }
+ context.pop();
+ Ok(())
+ }
+
+ let mut context = Vec::new();
+
+ try!(write!(f,
+r"<h1 class='fqn'>Stability dashboard: crate <a class='mod' href='index.html'>{}</a></h1>
+This dashboard summarizes the stability levels for all of the public modules of
+the crate, according to the total number of items at each level in the module and its children:
+<blockquote>
+<a class='stability Stable'></a> stable,<br/>
+<a class='stability Unstable'></a> unstable,<br/>
+<a class='stability Experimental'></a> experimental,<br/>
+<a class='stability Deprecated'></a> deprecated,<br/>
+<a class='stability Unmarked'></a> unmarked
+</blockquote>
+The counts do not include methods or trait
+implementations that are visible only through a re-exported type.",
+self.name));
+ try!(write!(f, "<table>"))
+ try!(fmt_inner(f, &mut context, self));
+ write!(f, "</table>")
+ }
+}
use externalfiles::ExternalHtml;
+use serialize::json;
+use serialize::Encodable;
use serialize::json::ToJson;
use syntax::ast;
use syntax::ast_util;
use html::layout;
use html::markdown::Markdown;
use html::markdown;
+use stability_summary;
/// Major driving force in all rustdoc rendering. This contains information
/// about where in the tree-like hierarchy rendering is occurring and controls
try!(mkdir(&cx.dst));
+ // Crawl the crate, building a summary of the stability levels. NOTE: this
+ // summary *must* be computed with the original `krate`; the folding below
+ // removes the impls from their modules.
+ let summary = stability_summary::build(&krate);
+
// Crawl the crate attributes looking for attributes which control how we're
// going to emit HTML
match krate.module.as_ref().map(|m| m.doc_list().unwrap_or(&[])) {
let krate = try!(render_sources(&mut cx, krate));
// And finally render the whole crate's documentation
- cx.krate(krate)
+ cx.krate(krate, summary)
}
fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult<String> {
///
/// This currently isn't parallelized, but it'd be pretty easy to add
/// parallelization to this function.
- fn krate(self, mut krate: clean::Crate) -> io::IoResult<()> {
+ fn krate(mut self, mut krate: clean::Crate,
+ stability: stability_summary::ModuleSummary) -> io::IoResult<()> {
let mut item = match krate.module.take() {
Some(i) => i,
None => return Ok(())
};
item.name = Some(krate.name);
+ // render stability dashboard
+ try!(self.recurse(stability.name.clone(), |this| {
+ let json_dst = &this.dst.join("stability.json");
+ let mut json_out = BufferedWriter::new(try!(File::create(json_dst)));
+ try!(stability.encode(&mut json::Encoder::new(&mut json_out)));
+
+ let title = stability.name.clone().append(" - Stability dashboard");
+ let page = layout::Page {
+ ty: "mod",
+ root_path: this.root_path.as_slice(),
+ title: title.as_slice(),
+ };
+ let html_dst = &this.dst.join("stability.html");
+ let mut html_out = BufferedWriter::new(try!(File::create(html_dst)));
+ layout::render(&mut html_out, &this.layout, &page,
+ &Sidebar{ cx: this, item: &item },
+ &stability)
+ }));
+
+ // render the crate documentation
let mut work = vec!((self, item));
loop {
match work.pop() {
None => break,
}
}
+
Ok(())
}
}
}
+
+
impl<'a> fmt::Show for Item<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
// Write the breadcrumb trail header for the top
// Write stability level
try!(write!(fmt, "{}", Stability(&self.item.stability)));
+ // Links to out-of-band information, i.e. src and stability dashboard
+ try!(write!(fmt, "<span class='out-of-band'>"));
+
+ // Write stability dashboard link
+ match self.item.inner {
+ clean::ModuleItem(ref m) if m.is_crate => {
+ try!(write!(fmt, "<a href='stability.html'>[stability dashboard]</a> "));
+ }
+ _ => {}
+ };
+
// Write `src` tag
//
// When this item is part of a `pub use` in a downstream crate, the
if self.cx.include_sources && !is_primitive {
match self.href() {
Some(l) => {
- try!(write!(fmt,
- "<a class='source' id='src-{}' \
- href='{}'>[src]</a>",
+ try!(write!(fmt, "<a id='src-{}' href='{}'>[src]</a>",
self.item.def_id.node, l));
}
None => {}
}
}
+
+ try!(write!(fmt, "</span>"));
+
try!(write!(fmt, "</h1>\n"));
match self.item.inner {
fn item_module(w: &mut fmt::Formatter, cx: &Context,
item: &clean::Item, items: &[clean::Item]) -> fmt::Result {
try!(document(w, item));
+
let mut indices = range(0, items.len()).filter(|i| {
!ignore_private_item(&items[*i])
}).collect::<Vec<uint>>();
}
}
}
+
write!(w, "</table>")
}
.docblock h2 { font-size: 1.15em; }
.docblock h3, .docblock h4, .docblock h5 { font-size: 1em; }
-.content .source {
+.content .out-of-band {
float: right;
font-size: 23px;
}
.stability.Locked { border-color: #0084B6; color: #00668c; }
.stability.Unmarked { border-color: #FFFFFF; }
+.summary {
+ padding-right: 0px;
+}
+.summary.Deprecated { background-color: #A071A8; }
+.summary.Experimental { background-color: #D46D6A; }
+.summary.Unstable { background-color: #D4B16A; }
+.summary.Stable { background-color: #54A759; }
+.summary.Unmarked { background-color: #FFFFFF; }
+
:target { background: #FDFFD3; }
/* Code highlighting */
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![crate_id = "rustdoc#0.11.0"] // NOTE: remove after stage0
#![crate_name = "rustdoc"]
#![experimental]
#![desc = "rustdoc, the Rust documentation extractor"]
#![license = "MIT/ASL2"]
#![crate_type = "dylib"]
#![crate_type = "rlib"]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![feature(globs, struct_variant, managed_boxes, macro_rules, phase)]
pub mod markdown;
pub mod passes;
pub mod plugins;
+pub mod stability_summary;
pub mod visit_ast;
pub mod test;
mod flock;
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! This module crawls a `clean::Crate` and produces a summarization of the
+//! stability levels within the crate. The summary contains the module
+//! hierarchy, with item counts for every stability level per module. A parent
+//! module's count includes its childrens's.
+
+use std::ops::Add;
+use std::num::Zero;
+use std::iter::AdditiveIterator;
+
+use syntax::attr::{Deprecated, Experimental, Unstable, Stable, Frozen, Locked};
+use syntax::ast::Public;
+
+use clean::{Crate, Item, ModuleItem, Module, StructItem, Struct, EnumItem, Enum};
+use clean::{ImplItem, Impl, TraitItem, Trait, TraitMethod, Provided, Required};
+use clean::{ViewItemItem, PrimitiveItem};
+
+#[deriving(Zero, Encodable, Decodable, PartialEq, Eq)]
+/// The counts for each stability level.
+pub struct Counts {
+ pub deprecated: uint,
+ pub experimental: uint,
+ pub unstable: uint,
+ pub stable: uint,
+ pub frozen: uint,
+ pub locked: uint,
+
+ /// No stability level, inherited or otherwise.
+ pub unmarked: uint,
+}
+
+impl Add<Counts, Counts> for Counts {
+ fn add(&self, other: &Counts) -> Counts {
+ Counts {
+ deprecated: self.deprecated + other.deprecated,
+ experimental: self.experimental + other.experimental,
+ unstable: self.unstable + other.unstable,
+ stable: self.stable + other.stable,
+ frozen: self.frozen + other.frozen,
+ locked: self.locked + other.locked,
+ unmarked: self.unmarked + other.unmarked,
+ }
+ }
+}
+
+impl Counts {
+ pub fn total(&self) -> uint {
+ self.deprecated + self.experimental + self.unstable + self.stable +
+ self.frozen + self.locked + self.unmarked
+ }
+}
+
+#[deriving(Encodable, Decodable, PartialEq, Eq)]
+/// A summarized module, which includes total counts and summarized chilcren
+/// modules.
+pub struct ModuleSummary {
+ pub name: String,
+ pub counts: Counts,
+ pub submodules: Vec<ModuleSummary>,
+}
+
+impl PartialOrd for ModuleSummary {
+ fn partial_cmp(&self, other: &ModuleSummary) -> Option<Ordering> {
+ self.name.partial_cmp(&other.name)
+ }
+}
+
+impl Ord for ModuleSummary {
+ fn cmp(&self, other: &ModuleSummary) -> Ordering {
+ self.name.cmp(&other.name)
+ }
+}
+
+// is the item considered publically visible?
+fn visible(item: &Item) -> bool {
+ match item.inner {
+ ImplItem(_) => true,
+ _ => item.visibility == Some(Public)
+ }
+}
+
+// Produce the summary for an arbitrary item. If the item is a module, include a
+// module summary. The counts for items with nested items (e.g. modules, traits,
+// impls) include all children counts.
+fn summarize_item(item: &Item) -> (Counts, Option<ModuleSummary>) {
+ // count this item
+ let item_counts = match item.stability {
+ None => Counts { unmarked: 1, .. Zero::zero() },
+ Some(ref stab) => match stab.level {
+ Deprecated => Counts { deprecated: 1, .. Zero::zero() },
+ Experimental => Counts { experimental: 1, .. Zero::zero() },
+ Unstable => Counts { unstable: 1, .. Zero::zero() },
+ Stable => Counts { stable: 1, .. Zero::zero() },
+ Frozen => Counts { frozen: 1, .. Zero::zero() },
+ Locked => Counts { locked: 1, .. Zero::zero() },
+ }
+ };
+
+ // Count this item's children, if any. Note that a trait impl is
+ // considered to have no children.
+ match item.inner {
+ // Require explicit `pub` to be visible
+ StructItem(Struct { fields: ref subitems, .. }) |
+ ImplItem(Impl { methods: ref subitems, trait_: None, .. }) => {
+ let subcounts = subitems.iter().filter(|i| visible(*i))
+ .map(summarize_item)
+ .map(|s| s.val0())
+ .sum();
+ (item_counts + subcounts, None)
+ }
+ // `pub` automatically
+ EnumItem(Enum { variants: ref subitems, .. }) => {
+ let subcounts = subitems.iter().map(summarize_item)
+ .map(|s| s.val0())
+ .sum();
+ (item_counts + subcounts, None)
+ }
+ TraitItem(Trait { methods: ref methods, .. }) => {
+ fn extract_item<'a>(meth: &'a TraitMethod) -> &'a Item {
+ match *meth {
+ Provided(ref item) | Required(ref item) => item
+ }
+ }
+ let subcounts = methods.iter().map(extract_item)
+ .map(summarize_item)
+ .map(|s| s.val0())
+ .sum();
+ (item_counts + subcounts, None)
+ }
+ ModuleItem(Module { items: ref items, .. }) => {
+ let mut counts = item_counts;
+ let mut submodules = Vec::new();
+
+ for (subcounts, submodule) in items.iter().filter(|i| visible(*i))
+ .map(summarize_item) {
+ counts = counts + subcounts;
+ submodule.map(|m| submodules.push(m));
+ }
+ submodules.sort();
+
+ (counts, Some(ModuleSummary {
+ name: item.name.as_ref().map_or("".to_string(), |n| n.clone()),
+ counts: counts,
+ submodules: submodules,
+ }))
+ }
+ // no stability information for the following items:
+ ViewItemItem(_) | PrimitiveItem(_) => (Zero::zero(), None),
+ _ => (item_counts, None)
+ }
+}
+
+/// Summarizes the stability levels in a crate.
+pub fn build(krate: &Crate) -> ModuleSummary {
+ match krate.module {
+ None => ModuleSummary {
+ name: krate.name.clone(),
+ counts: Zero::zero(),
+ submodules: Vec::new(),
+ },
+ Some(ref item) => ModuleSummary {
+ name: krate.name.clone(), .. summarize_item(item).val1().unwrap()
+ }
+ }
+}
let codemap = CodeMap::new();
- let diagnostic_handler = diagnostic::default_handler(diagnostic::Auto);
+ let diagnostic_handler = diagnostic::default_handler(diagnostic::Auto, None);
let span_diagnostic_handler =
diagnostic::mk_span_handler(diagnostic_handler, codemap);
};
io::util::copy(&mut p, &mut err).unwrap();
});
- let emitter = diagnostic::EmitterWriter::new(box w2);
+ let emitter = diagnostic::EmitterWriter::new(box w2, None);
// Compile the code
let codemap = CodeMap::new();
// environment to ensure that the target loads the right libraries at
// runtime. It would be a sad day if the *host* libraries were loaded as a
// mistake.
- let exe = outdir.path().join("rust_out");
- let env = {
+ let mut cmd = Command::new(outdir.path().join("rust_out"));
+ let newpath = {
let mut path = DynamicLibrary::search_path();
path.insert(0, libdir.clone());
-
- // Remove the previous dylib search path var
- let var = DynamicLibrary::envvar();
- let mut env: Vec<(String,String)> = os::env().move_iter().collect();
- match env.iter().position(|&(ref k, _)| k.as_slice() == var) {
- Some(i) => { env.remove(i); }
- None => {}
- };
-
- // Add the new dylib search path var
- let newpath = DynamicLibrary::create_path(path.as_slice());
- env.push((var.to_string(),
- str::from_utf8(newpath.as_slice()).unwrap().to_string()));
- env
+ DynamicLibrary::create_path(path.as_slice())
};
- match Command::new(exe).env(env.as_slice()).output() {
+ cmd.env(DynamicLibrary::envvar(), newpath.as_slice());
+
+ match cmd.output() {
Err(e) => fail!("couldn't run the test: {}{}", e,
if e.kind == io::PermissionDenied {
" - maybe your tempdir is mounted with noexec?"
use alloc::libc_heap::malloc_raw;
use collections::string::String;
+use collections::hash;
use core::kinds::marker;
use core::mem;
use core::ptr;
}
}
+impl PartialOrd for CString {
+ #[inline]
+ fn partial_cmp(&self, other: &CString) -> Option<Ordering> {
+ self.as_bytes().partial_cmp(&other.as_bytes())
+ }
+}
+
+impl Eq for CString {}
+
+impl<S: hash::Writer> hash::Hash<S> for CString {
+ #[inline]
+ fn hash(&self, state: &mut S) {
+ self.as_bytes().hash(state)
+ }
+}
+
impl CString {
/// Create a C String from a pointer.
pub unsafe fn new(buf: *const libc::c_char, owns_buffer: bool) -> CString {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![crate_id = "rustrt#0.11.0"] // NOTE: remove after stage0
#![crate_name = "rustrt"]
#![license = "MIT/ASL2"]
#![crate_type = "rlib"]
html_root_url = "http://doc.rust-lang.org/0.11.0/")]
#![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm)]
-#![feature(linkage, lang_items, unsafe_destructor)]
+#![feature(linkage, lang_items, unsafe_destructor, default_type_params)]
#![no_std]
#![experimental]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#[phase(plugin, link)] extern crate core;
extern crate alloc;
/// Optional environment to specify for the program. If this is None, then
/// it will inherit the current process's environment.
- pub env: Option<&'a [(CString, CString)]>,
+ pub env: Option<&'a [(&'a CString, &'a CString)]>,
/// Optional working directory for the new process. If this is None, then
/// the current directory of the running process is inherited.
*/
-#![crate_id = "rustuv#0.11.0"] // NOTE: remove after stage0
#![crate_name = "rustuv"]
#![experimental]
#![license = "MIT/ASL2"]
#![feature(macro_rules, unsafe_destructor)]
#![deny(unused_result, unused_must_use)]
#![allow(visible_private_types)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#[cfg(test)] extern crate green;
#[cfg(test)] extern crate debug;
}
/// Converts the environment to the env array expected by libuv
-fn with_env<T>(env: Option<&[(CString, CString)]>,
+fn with_env<T>(env: Option<&[(&CString, &CString)]>,
cb: |*const *const libc::c_char| -> T) -> T {
// We can pass a char** for envp, which is a null-terminated array
// of "k=v\0" strings. Since we must create these strings locally,
//! An example version number with all five components is
//! `0.8.1-rc.3.0+20130922.linux`.
-#![crate_id = "semver#0.11.0"] // NOTE: remove after stage0
#![crate_name = "semver"]
#![experimental]
#![crate_type = "rlib"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
+#![feature(default_type_params)]
use std::char;
use std::cmp;
-use std::fmt;
use std::fmt::Show;
-use std::option::{Option, Some, None};
-use std::string::String;
+use std::fmt;
+use std::hash;
/// An identifier in the pre-release or build metadata. If the identifier can
/// be parsed as a decimal value, it will be represented with `Numeric`.
-#[deriving(Clone, PartialEq)]
+#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[allow(missing_doc)]
pub enum Identifier {
Numeric(uint),
AlphaNumeric(String)
}
-impl cmp::PartialOrd for Identifier {
- #[inline]
- fn partial_cmp(&self, other: &Identifier) -> Option<Ordering> {
- match (self, other) {
- (&Numeric(a), &Numeric(ref b)) => a.partial_cmp(b),
- (&Numeric(_), _) => Some(Less),
- (&AlphaNumeric(ref a), &AlphaNumeric(ref b)) => a.partial_cmp(b),
- (&AlphaNumeric(_), _) => Some(Greater)
- }
- }
-}
-
impl fmt::Show for Identifier {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
/// Represents a version number conforming to the semantic versioning scheme.
-#[deriving(Clone)]
+#[deriving(Clone, Eq)]
pub struct Version {
/// The major version, to be incremented on incompatible changes.
pub major: uint,
}
impl cmp::PartialOrd for Version {
- #[inline]
fn partial_cmp(&self, other: &Version) -> Option<Ordering> {
- match self.major.partial_cmp(&other.major) {
- Some(Equal) => {}
+ Some(self.cmp(other))
+ }
+}
+
+impl cmp::Ord for Version {
+ fn cmp(&self, other: &Version) -> Ordering {
+ match self.major.cmp(&other.major) {
+ Equal => {}
r => return r,
}
- match self.minor.partial_cmp(&other.minor) {
- Some(Equal) => {}
+ match self.minor.cmp(&other.minor) {
+ Equal => {}
r => return r,
}
- match self.patch.partial_cmp(&other.patch) {
- Some(Equal) => {}
+ match self.patch.cmp(&other.patch) {
+ Equal => {}
r => return r,
}
// but the version of ord defined for vec
// says that [] < [pre] so we alter it here
match (self.pre.len(), other.pre.len()) {
- (0, 0) => Some(Equal),
- (0, _) => Some(Greater),
- (_, 0) => Some(Less),
- (_, _) => self.pre.partial_cmp(&other.pre)
+ (0, 0) => Equal,
+ (0, _) => Greater,
+ (_, 0) => Less,
+ (_, _) => self.pre.cmp(&other.pre)
}
}
}
+impl<S: hash::Writer> hash::Hash<S> for Version {
+ fn hash(&self, into: &mut S) {
+ self.major.hash(into);
+ self.minor.hash(into);
+ self.patch.hash(into);
+ self.pre.hash(into);
+ }
+}
+
fn take_nonempty_prefix<T:Iterator<char>>(rdr: &mut T, pred: |char| -> bool)
-> (String, Option<char>) {
let mut buf = String::new();
Core encoding and decoding interfaces.
*/
-#![crate_id = "serialize#0.11.0"] // NOTE: remove after stage0
#![crate_name = "serialize"]
#![experimental]
#![crate_type = "rlib"]
html_root_url = "http://doc.rust-lang.org/0.11.0/",
html_playground_url = "http://play.rust-lang.org/")]
#![feature(macro_rules, managed_boxes, default_type_params, phase)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
// test harness access
#[cfg(test)]
#[inline]
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
// return an error if the entire write does not fit in the buffer
- let max_size = self.buf.len();
- if self.pos >= max_size || (self.pos + buf.len()) > max_size {
+ let cap = if self.pos >= self.buf.len() { 0 } else { self.buf.len() - self.pos };
+ if buf.len() > cap {
return Err(IoError {
kind: io::OtherIoError,
desc: "Trying to write past end of buffer",
writer.write([1, 2, 3]).unwrap();
writer.write([4, 5, 6, 7]).unwrap();
assert_eq!(writer.tell(), Ok(8));
+ writer.write([]).unwrap();
+ assert_eq!(writer.tell(), Ok(8));
}
assert_eq!(buf.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7]);
}
assert_eq!(buf.as_slice(), &[7, 8, 6]);
}
- #[bench]
- fn bench_mem_writer(b: &mut Bencher) {
+ fn do_bench_mem_writer(b: &mut Bencher, times: uint, len: uint) {
+ let src: Vec<u8> = Vec::from_elem(len, 5);
+
b.iter(|| {
let mut wr = MemWriter::new();
- for _i in range(0u, 10) {
- wr.write([5, .. 10]).unwrap();
+ for _ in range(0, times) {
+ wr.write(src.as_slice()).unwrap();
}
- assert_eq!(wr.unwrap().as_slice(), [5, .. 100].as_slice());
+
+ let v = wr.unwrap();
+ assert_eq!(v.len(), times * len);
+ assert!(v.iter().all(|x| *x == 5));
});
}
+ #[bench]
+ fn bench_mem_writer_001_0000(b: &mut Bencher) {
+ do_bench_mem_writer(b, 1, 0)
+ }
+
+ #[bench]
+ fn bench_mem_writer_001_0010(b: &mut Bencher) {
+ do_bench_mem_writer(b, 1, 10)
+ }
+
+ #[bench]
+ fn bench_mem_writer_001_0100(b: &mut Bencher) {
+ do_bench_mem_writer(b, 1, 100)
+ }
+
+ #[bench]
+ fn bench_mem_writer_001_1000(b: &mut Bencher) {
+ do_bench_mem_writer(b, 1, 1000)
+ }
+
+ #[bench]
+ fn bench_mem_writer_100_0000(b: &mut Bencher) {
+ do_bench_mem_writer(b, 100, 0)
+ }
+
+ #[bench]
+ fn bench_mem_writer_100_0010(b: &mut Bencher) {
+ do_bench_mem_writer(b, 100, 10)
+ }
+
+ #[bench]
+ fn bench_mem_writer_100_0100(b: &mut Bencher) {
+ do_bench_mem_writer(b, 100, 100)
+ }
+
+ #[bench]
+ fn bench_mem_writer_100_1000(b: &mut Bencher) {
+ do_bench_mem_writer(b, 100, 1000)
+ }
+
#[bench]
fn bench_mem_reader(b: &mut Bencher) {
b.iter(|| {
use str;
use string::String;
use uint;
+use unicode::UnicodeChar;
use vec::Vec;
// Reexports
use str;
use fmt;
+use os;
use io::{IoResult, IoError};
use io;
use libc;
use rt::rtio::{RtioProcess, ProcessConfig, IoFactory, LocalIo};
use rt::rtio;
use c_str::CString;
+use collections::HashMap;
/// Signal a process to exit, without forcibly killing it. Corresponds to
/// SIGTERM on unix platforms.
pub extra_io: Vec<Option<io::PipeStream>>,
}
+/// A HashMap representation of environment variables.
+pub type EnvMap = HashMap<CString, CString>;
+
/// The `Command` type acts as a process builder, providing fine-grained control
/// over how a new process should be spawned. A default configuration can be
/// generated using `Command::new(program)`, where `program` gives a path to the
///
/// let output = process.stdout.get_mut_ref().read_to_end();
/// ```
+#[deriving(Clone)]
pub struct Command {
// The internal data for the builder. Documented by the builder
// methods below, and serialized into rt::rtio::ProcessConfig.
program: CString,
args: Vec<CString>,
- env: Option<Vec<(CString, CString)>>,
+ env: Option<EnvMap>,
cwd: Option<CString>,
stdin: StdioContainer,
stdout: StdioContainer,
}
/// Add an argument to pass to the program.
- pub fn arg<'a, T:ToCStr>(&'a mut self, arg: T) -> &'a mut Command {
+ pub fn arg<'a, T: ToCStr>(&'a mut self, arg: T) -> &'a mut Command {
self.args.push(arg.to_c_str());
self
}
/// Add multiple arguments to pass to the program.
- pub fn args<'a, T:ToCStr>(&'a mut self, args: &[T]) -> &'a mut Command {
+ pub fn args<'a, T: ToCStr>(&'a mut self, args: &[T]) -> &'a mut Command {
self.args.extend(args.iter().map(|arg| arg.to_c_str()));;
self
}
+ // Get a mutable borrow of the environment variable map for this `Command`.
+ fn get_env_map<'a>(&'a mut self) -> &'a mut EnvMap {
+ match self.env {
+ Some(ref mut map) => map,
+ None => {
+ // if the env is currently just inheriting from the parent's,
+ // materialize the parent's env into a hashtable.
+ self.env = Some(os::env_as_bytes().move_iter()
+ .map(|(k, v)| (k.as_slice().to_c_str(),
+ v.as_slice().to_c_str()))
+ .collect());
+ self.env.as_mut().unwrap()
+ }
+ }
+ }
- /// Sets the environment for the child process (rather than inheriting it
- /// from the current process).
-
- // FIXME (#13851): We should change this interface to allow clients to (1)
- // build up the env vector incrementally and (2) allow both inheriting the
- // current process's environment AND overriding/adding additional
- // environment variables. The underlying syscalls assume that the
- // environment has no duplicate names, so we really want to use a hashtable
- // to compute the environment to pass down to the syscall; resolving issue
- // #13851 will make it possible to use the standard hashtable.
- pub fn env<'a, T:ToCStr>(&'a mut self, env: &[(T,T)]) -> &'a mut Command {
- self.env = Some(env.iter().map(|&(ref name, ref val)| {
- (name.to_c_str(), val.to_c_str())
- }).collect());
+ /// Inserts or updates an environment variable mapping.
+ pub fn env<'a, T: ToCStr, U: ToCStr>(&'a mut self, key: T, val: U)
+ -> &'a mut Command {
+ self.get_env_map().insert(key.to_c_str(), val.to_c_str());
+ self
+ }
+
+ /// Removes an environment variable mapping.
+ pub fn env_remove<'a, T: ToCStr>(&'a mut self, key: T) -> &'a mut Command {
+ self.get_env_map().remove(&key.to_c_str());
+ self
+ }
+
+ /// Sets the entire environment map for the child process.
+ ///
+ /// If the given slice contains multiple instances of an environment
+ /// variable, the *rightmost* instance will determine the value.
+ pub fn env_set_all<'a, T: ToCStr, U: ToCStr>(&'a mut self, env: &[(T,U)])
+ -> &'a mut Command {
+ self.env = Some(env.iter().map(|&(ref k, ref v)| (k.to_c_str(), v.to_c_str()))
+ .collect());
self
}
let extra_io: Vec<rtio::StdioContainer> =
self.extra_io.iter().map(|x| to_rtio(*x)).collect();
LocalIo::maybe_raise(|io| {
+ let env = match self.env {
+ None => None,
+ Some(ref env_map) =>
+ Some(env_map.iter().collect::<Vec<_>>())
+ };
let cfg = ProcessConfig {
program: &self.program,
args: self.args.as_slice(),
- env: self.env.as_ref().map(|env| env.as_slice()),
+ env: env.as_ref().map(|e| e.as_slice()),
cwd: self.cwd.as_ref(),
stdin: to_rtio(self.stdin),
stdout: to_rtio(self.stdout),
}
/// Describes what to do with a standard io stream for a child process.
+#[deriving(Clone)]
pub enum StdioContainer {
/// This stream will be ignored. This is the equivalent of attaching the
/// stream to `/dev/null`
}
})
- iotest!(fn test_add_to_env() {
+ iotest!(fn test_override_env() {
let new_env = vec![("RUN_TEST_NEW_ENV", "123")];
- let prog = env_cmd().env(new_env.as_slice()).spawn().unwrap();
+ let prog = env_cmd().env_set_all(new_env.as_slice()).spawn().unwrap();
let result = prog.wait_with_output().unwrap();
let output = str::from_utf8_lossy(result.output.as_slice()).into_string();
"didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
})
+ iotest!(fn test_add_to_env() {
+ let prog = env_cmd().env("RUN_TEST_NEW_ENV", "123").spawn().unwrap();
+ let result = prog.wait_with_output().unwrap();
+ let output = str::from_utf8_lossy(result.output.as_slice()).into_string();
+
+ assert!(output.as_slice().contains("RUN_TEST_NEW_ENV=123"),
+ "didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
+ })
+
+ iotest!(fn test_remove_from_env() {
+ use os;
+
+ // save original environment
+ let old_env = os::getenv("RUN_TEST_NEW_ENV");
+
+ os::setenv("RUN_TEST_NEW_ENV", "123");
+ let prog = env_cmd().env_remove("RUN_TEST_NEW_ENV").spawn().unwrap();
+ let result = prog.wait_with_output().unwrap();
+ let output = str::from_utf8_lossy(result.output.as_slice()).into_string();
+
+ // restore original environment
+ match old_env {
+ None => {
+ os::unsetenv("RUN_TEST_NEW_ENV");
+ }
+ Some(val) => {
+ os::setenv("RUN_TEST_NEW_ENV", val.as_slice());
+ }
+ }
+
+ assert!(!output.as_slice().contains("RUN_TEST_NEW_ENV"),
+ "found RUN_TEST_NEW_ENV inside of:\n\n{}", output);
+ })
+
#[cfg(unix)]
pub fn sleeper() -> Process {
Command::new("sleep").arg("1000").spawn().unwrap()
//! all the standard macros, such as `assert!`, `fail!`, `println!`,
//! and `format!`, also available to all Rust code.
-#![crate_id = "std#0.11.0"] // NOTE: remove after stage0 snap
#![crate_name = "std"]
#![unstable]
#![comment = "The Rust standard library"]
#![feature(macro_rules, globs, managed_boxes, linkage)]
#![feature(default_type_params, phase, lang_items, unsafe_destructor)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
// Don't link to std. We are std.
#![no_std]
#[cfg(test)] #[phase(plugin, link)] extern crate log;
extern crate alloc;
+extern crate unicode;
extern crate core;
extern crate core_collections = "collections";
extern crate core_rand = "rand";
pub use core::any;
pub use core::bool;
pub use core::cell;
-pub use core::char;
pub use core::clone;
#[cfg(not(test))] pub use core::cmp;
pub use core::default;
pub use rustrt::c_str;
pub use rustrt::local_data;
+pub use unicode::char;
+
pub use core_sync::comm;
// Run tests with libgreen instead of libnative.
// The test runner requires std::slice::Vector, so re-export std::slice just for it.
#[cfg(test)] pub use slice;
}
-
-#[deprecated]
-#[allow(missing_doc)]
-#[doc(hiden)]
-pub mod unstable {
- #[deprecated = "use std::dynamic_lib"]
- pub use dynamic_lib;
-}
/// The memory map is released (unmapped) when the destructor is run, so don't
/// let it leave scope by accident if you want it to stick around.
pub struct MemoryMap {
- /// Pointer to the memory created or modified by this map.
- pub data: *mut u8,
- /// Number of bytes this map applies to
- pub len: uint,
- /// Type of mapping
- pub kind: MemoryMapKind,
+ data: *mut u8,
+ len: uint,
+ kind: MemoryMapKind,
}
/// Type of memory map
}
}
+impl MemoryMap {
+ /// Returns the pointer to the memory created or modified by this map.
+ pub fn data(&self) -> *mut u8 { self.data }
+ /// Returns the number of bytes this map applies to.
+ pub fn len(&self) -> uint { self.len }
+ /// Returns the type of mapping this represents.
+ pub fn kind(&self) -> MemoryMapKind { self.kind }
+}
+
#[cfg(target_os = "linux")]
pub mod consts {
pub use os::arch_consts::ARCH;
use c_str::{CString, ToCStr};
use clone::Clone;
-use cmp::{PartialEq, Eq};
+use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
use collections::Collection;
use from_str::FromStr;
use hash;
impl Eq for Path {}
+impl PartialOrd for Path {
+ fn partial_cmp(&self, other: &Path) -> Option<Ordering> {
+ Some(self.cmp(other))
+ }
+}
+
+impl Ord for Path {
+ fn cmp(&self, other: &Path) -> Ordering {
+ self.repr.cmp(&other.repr)
+ }
+}
+
impl FromStr for Path {
fn from_str(s: &str) -> Option<Path> {
Path::new_opt(s)
use ascii::AsciiCast;
use c_str::{CString, ToCStr};
use clone::Clone;
-use cmp::{PartialEq, Eq};
+use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
use collections::Collection;
use from_str::FromStr;
use hash;
use slice::{Vector, ImmutableVector};
use str::{CharSplits, Str, StrAllocating, StrVector, StrSlice};
use string::String;
+use unicode::UnicodeChar;
use vec::Vec;
use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe};
impl Eq for Path {}
+impl PartialOrd for Path {
+ fn partial_cmp(&self, other: &Path) -> Option<Ordering> {
+ Some(self.cmp(other))
+ }
+}
+
+impl Ord for Path {
+ fn cmp(&self, other: &Path) -> Ordering {
+ self.repr.cmp(&other.repr)
+ }
+}
+
impl FromStr for Path {
fn from_str(s: &str) -> Option<Path> {
Path::new_opt(s)
let idx = path.find('\\');
if idx == Some(2) && path.as_bytes()[1] == ':' as u8 {
let c = path.as_bytes()[0];
- if c.is_ascii() && ::char::is_alphabetic(c as char) {
+ if c.is_ascii() && (c as char).is_alphabetic() {
// \\?\C:\ path
return Some(VerbatimDiskPrefix);
}
} else if path.len() > 1 && path.as_bytes()[1] == ':' as u8 {
// C:
let c = path.as_bytes()[0];
- if c.is_ascii() && ::char::is_alphabetic(c as char) {
+ if c.is_ascii() && (c as char).is_alphabetic() {
return Some(DiskPrefix);
}
}
#[doc(no_inline)] pub use ops::{BitAnd, BitOr, BitXor};
#[doc(no_inline)] pub use ops::{Drop, Deref, DerefMut};
#[doc(no_inline)] pub use ops::{Shl, Shr};
-#[doc(no_inline)] #[cfg(not(stage0))] pub use ops::{Index, IndexMut};
+#[doc(no_inline)] pub use ops::{Index, IndexMut};
#[doc(no_inline)] pub use option::{Option, Some, None};
#[doc(no_inline)] pub use result::{Result, Ok, Err};
#[doc(no_inline)] pub use slice::{Vector, VectorVector};
#[doc(no_inline)] pub use slice::MutableVectorAllocating;
#[doc(no_inline)] pub use string::String;
+#[doc(no_inline)] pub use unicode::{UnicodeChar, UnicodeStrSlice};
#[doc(no_inline)] pub use vec::Vec;
// Reexported runtime types
#![allow(non_camel_case_types)]
-use char::Char;
use collections::Collection;
use from_str::from_str;
use io::{IoResult, Writer};
use result::{Ok, Err};
use str::StrSlice;
use sync::atomics;
+use unicode::UnicodeChar;
pub use self::imp::write;
//! use this crate specifically. Instead, its functionality is reexported
//! through `std::sync`.
-#![crate_id = "sync#0.11.0"] // NOTE: remove after stage0 snap
#![crate_name = "sync"]
#![experimental]
#![crate_type = "rlib"]
#![feature(phase, globs, macro_rules, unsafe_destructor)]
#![deny(missing_doc)]
#![no_std]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#[phase(plugin, link)] extern crate core;
extern crate alloc;
AbiData {abi: RustIntrinsic, name: "rust-intrinsic", abi_arch: RustArch},
];
-/// Iterates through each of the defined ABIs.
-fn each_abi(op: |abi: Abi| -> bool) -> bool {
- AbiDatas.iter().advance(|abi_data| op(abi_data.abi))
-}
-
/// Returns the ABI with the given name (if any).
pub fn lookup(name: &str) -> Option<Abi> {
- let mut res = None;
-
- each_abi(|abi| {
- if name == abi.data().name {
- res = Some(abi);
- false
- } else {
- true
- }
- });
- res
+ AbiDatas.iter().find(|abi_data| name == abi_data.name).map(|&x| x.abi)
}
pub fn all_names() -> Vec<&'static str> {
TTNonterminal(Span, Ident)
}
-/// Matchers are nodes defined-by and recognized-by the main rust parser and
-/// language, but they're only ever found inside syntax-extension invocations;
-/// indeed, the only thing that ever _activates_ the rules in the rust parser
-/// for parsing a matcher is a matcher looking for the 'matchers' nonterminal
-/// itself. Matchers represent a small sub-language for pattern-matching
-/// token-trees, and are thus primarily used by the macro-defining extension
-/// itself.
-///
-/// MatchTok
-/// --------
-///
-/// A matcher that matches a single token, denoted by the token itself. So
-/// long as there's no $ involved.
-///
-///
-/// MatchSeq
-/// --------
-///
-/// A matcher that matches a sequence of sub-matchers, denoted various
-/// possible ways:
-///
-/// $(M)* zero or more Ms
-/// $(M)+ one or more Ms
-/// $(M),+ one or more comma-separated Ms
-/// $(A B C);* zero or more semi-separated 'A B C' seqs
-///
-///
-/// MatchNonterminal
-/// -----------------
-///
-/// A matcher that matches one of a few interesting named rust
-/// nonterminals, such as types, expressions, items, or raw token-trees. A
-/// black-box matcher on expr, for example, binds an expr to a given ident,
-/// and that ident can re-occur as an interpolation in the RHS of a
-/// macro-by-example rule. For example:
-///
-/// $foo:expr => 1 + $foo // interpolate an expr
-/// $foo:tt => $foo // interpolate a token-tree
-/// $foo:tt => bar! $foo // only other valid interpolation
-/// // is in arg position for another
-/// // macro
-///
-/// As a final, horrifying aside, note that macro-by-example's input is
-/// also matched by one of these matchers. Holy self-referential! It is matched
-/// by a MatchSeq, specifically this one:
-///
-/// $( $lhs:matchers => $rhs:tt );+
-///
-/// If you understand that, you have closed the loop and understand the whole
-/// macro system. Congratulations.
+// Matchers are nodes defined-by and recognized-by the main rust parser and
+// language, but they're only ever found inside syntax-extension invocations;
+// indeed, the only thing that ever _activates_ the rules in the rust parser
+// for parsing a matcher is a matcher looking for the 'matchers' nonterminal
+// itself. Matchers represent a small sub-language for pattern-matching
+// token-trees, and are thus primarily used by the macro-defining extension
+// itself.
+//
+// MatchTok
+// --------
+//
+// A matcher that matches a single token, denoted by the token itself. So
+// long as there's no $ involved.
+//
+//
+// MatchSeq
+// --------
+//
+// A matcher that matches a sequence of sub-matchers, denoted various
+// possible ways:
+//
+// $(M)* zero or more Ms
+// $(M)+ one or more Ms
+// $(M),+ one or more comma-separated Ms
+// $(A B C);* zero or more semi-separated 'A B C' seqs
+//
+//
+// MatchNonterminal
+// -----------------
+//
+// A matcher that matches one of a few interesting named rust
+// nonterminals, such as types, expressions, items, or raw token-trees. A
+// black-box matcher on expr, for example, binds an expr to a given ident,
+// and that ident can re-occur as an interpolation in the RHS of a
+// macro-by-example rule. For example:
+//
+// $foo:expr => 1 + $foo // interpolate an expr
+// $foo:tt => $foo // interpolate a token-tree
+// $foo:tt => bar! $foo // only other valid interpolation
+// // is in arg position for another
+// // macro
+//
+// As a final, horrifying aside, note that macro-by-example's input is
+// also matched by one of these matchers. Holy self-referential! It is matched
+// by a MatchSeq, specifically this one:
+//
+// $( $lhs:matchers => $rhs:tt );+
+//
+// If you understand that, you have closed the loop and understand the whole
+// macro system. Congratulations.
pub type Matcher = Spanned<Matcher_>;
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
match pat.node {
PatIdent(_, _, Some(ref p)) => walk_pat(&**p, it),
PatStruct(_, ref fields, _) => {
- fields.iter().advance(|f| walk_pat(&*f.pat, |p| it(p)))
+ fields.iter().all(|field| walk_pat(&*field.pat, |p| it(p)))
}
PatEnum(_, Some(ref s)) | PatTup(ref s) => {
- s.iter().advance(|p| walk_pat(&**p, |p| it(p)))
+ s.iter().all(|p| walk_pat(&**p, |p| it(p)))
}
PatBox(ref s) | PatRegion(ref s) => {
walk_pat(&**s, it)
}
PatVec(ref before, ref slice, ref after) => {
- before.iter().advance(|p| walk_pat(&**p, |p| it(p))) &&
- slice.iter().advance(|p| walk_pat(&**p, |p| it(p))) &&
- after.iter().advance(|p| walk_pat(&**p, |p| it(p)))
+ before.iter().all(|p| walk_pat(&**p, |p| it(p))) &&
+ slice.iter().all(|p| walk_pat(&**p, |p| it(p))) &&
+ after.iter().all(|p| walk_pat(&**p, |p| it(p)))
}
PatMac(_) => fail!("attempted to analyze unexpanded pattern"),
PatWild | PatWildMulti | PatLit(_) | PatRange(_, _) | PatIdent(_, _, _) |
use codemap::{Pos, Span};
use codemap;
+use diagnostics;
use std::cell::{RefCell, Cell};
use std::fmt;
pub trait Emitter {
fn emit(&mut self, cmsp: Option<(&codemap::CodeMap, Span)>,
- msg: &str, lvl: Level);
+ msg: &str, code: Option<&str>, lvl: Level);
fn custom_emit(&mut self, cm: &codemap::CodeMap,
sp: RenderSpan, msg: &str, lvl: Level);
}
self.handler.emit(Some((&self.cm, sp)), msg, Error);
self.handler.bump_err_count();
}
+ pub fn span_err_with_code(&self, sp: Span, msg: &str, code: &str) {
+ self.handler.emit_with_code(Some((&self.cm, sp)), msg, code, Error);
+ self.handler.bump_err_count();
+ }
pub fn span_warn(&self, sp: Span, msg: &str) {
self.handler.emit(Some((&self.cm, sp)), msg, Warning);
}
impl Handler {
pub fn fatal(&self, msg: &str) -> ! {
- self.emit.borrow_mut().emit(None, msg, Fatal);
+ self.emit.borrow_mut().emit(None, msg, None, Fatal);
fail!(FatalError);
}
pub fn err(&self, msg: &str) {
- self.emit.borrow_mut().emit(None, msg, Error);
+ self.emit.borrow_mut().emit(None, msg, None, Error);
self.bump_err_count();
}
pub fn bump_err_count(&self) {
self.fatal(s.as_slice());
}
pub fn warn(&self, msg: &str) {
- self.emit.borrow_mut().emit(None, msg, Warning);
+ self.emit.borrow_mut().emit(None, msg, None, Warning);
}
pub fn note(&self, msg: &str) {
- self.emit.borrow_mut().emit(None, msg, Note);
+ self.emit.borrow_mut().emit(None, msg, None, Note);
}
pub fn bug(&self, msg: &str) -> ! {
- self.emit.borrow_mut().emit(None, msg, Bug);
+ self.emit.borrow_mut().emit(None, msg, None, Bug);
fail!(ExplicitBug);
}
pub fn unimpl(&self, msg: &str) -> ! {
cmsp: Option<(&codemap::CodeMap, Span)>,
msg: &str,
lvl: Level) {
- self.emit.borrow_mut().emit(cmsp, msg, lvl);
+ self.emit.borrow_mut().emit(cmsp, msg, None, lvl);
+ }
+ pub fn emit_with_code(&self,
+ cmsp: Option<(&codemap::CodeMap, Span)>,
+ msg: &str,
+ code: &str,
+ lvl: Level) {
+ self.emit.borrow_mut().emit(cmsp, msg, Some(code), lvl);
}
pub fn custom_emit(&self, cm: &codemap::CodeMap,
sp: RenderSpan, msg: &str, lvl: Level) {
}
}
-pub fn default_handler(color_config: ColorConfig) -> Handler {
- mk_handler(box EmitterWriter::stderr(color_config))
+pub fn default_handler(color_config: ColorConfig,
+ registry: Option<diagnostics::registry::Registry>) -> Handler {
+ mk_handler(box EmitterWriter::stderr(color_config, registry))
}
pub fn mk_handler(e: Box<Emitter + Send>) -> Handler {
}
}
-fn print_diagnostic(dst: &mut EmitterWriter,
- topic: &str, lvl: Level, msg: &str) -> io::IoResult<()> {
+fn print_diagnostic(dst: &mut EmitterWriter, topic: &str, lvl: Level,
+ msg: &str, code: Option<&str>) -> io::IoResult<()> {
if !topic.is_empty() {
try!(write!(&mut dst.dst, "{} ", topic));
}
format!("{}: ", lvl.to_string()).as_slice(),
term::attr::ForegroundColor(lvl.color())));
try!(print_maybe_styled(dst,
- format!("{}\n", msg).as_slice(),
+ format!("{}", msg).as_slice(),
term::attr::Bold));
+
+ match code {
+ Some(code) => {
+ let style = term::attr::ForegroundColor(term::color::BRIGHT_MAGENTA);
+ try!(print_maybe_styled(dst, format!(" [{}]", code.clone()).as_slice(), style));
+ match dst.registry.as_ref().and_then(|registry| registry.find_description(code)) {
+ Some(_) => {
+ try!(write!(&mut dst.dst,
+ " (pass `--explain {}` to see a detailed explanation)",
+ code
+ ));
+ }
+ None => ()
+ }
+ }
+ None => ()
+ }
+ try!(dst.dst.write_char('\n'));
Ok(())
}
pub struct EmitterWriter {
dst: Destination,
+ registry: Option<diagnostics::registry::Registry>
}
enum Destination {
}
impl EmitterWriter {
- pub fn stderr(color_config: ColorConfig) -> EmitterWriter {
+ pub fn stderr(color_config: ColorConfig,
+ registry: Option<diagnostics::registry::Registry>) -> EmitterWriter {
let stderr = io::stderr();
let use_color = match color_config {
Some(t) => Terminal(t),
None => Raw(box stderr),
};
- EmitterWriter { dst: dst }
+ EmitterWriter { dst: dst, registry: registry }
} else {
- EmitterWriter { dst: Raw(box stderr) }
+ EmitterWriter { dst: Raw(box stderr), registry: registry }
}
}
- pub fn new(dst: Box<Writer + Send>) -> EmitterWriter {
- EmitterWriter { dst: Raw(dst) }
+ pub fn new(dst: Box<Writer + Send>,
+ registry: Option<diagnostics::registry::Registry>) -> EmitterWriter {
+ EmitterWriter { dst: Raw(dst), registry: registry }
}
}
impl Emitter for EmitterWriter {
fn emit(&mut self,
cmsp: Option<(&codemap::CodeMap, Span)>,
- msg: &str,
- lvl: Level) {
+ msg: &str, code: Option<&str>, lvl: Level) {
let error = match cmsp {
- Some((cm, sp)) => emit(self, cm, FullSpan(sp), msg, lvl, false),
- None => print_diagnostic(self, "", lvl, msg),
+ Some((cm, sp)) => emit(self, cm, FullSpan(sp), msg, code, lvl, false),
+ None => print_diagnostic(self, "", lvl, msg, code),
};
match error {
fn custom_emit(&mut self, cm: &codemap::CodeMap,
sp: RenderSpan, msg: &str, lvl: Level) {
- match emit(self, cm, sp, msg, lvl, true) {
+ match emit(self, cm, sp, msg, None, lvl, true) {
Ok(()) => {}
Err(e) => fail!("failed to print diagnostics: {}", e),
}
}
fn emit(dst: &mut EmitterWriter, cm: &codemap::CodeMap, rsp: RenderSpan,
- msg: &str, lvl: Level, custom: bool) -> io::IoResult<()> {
+ msg: &str, code: Option<&str>, lvl: Level, custom: bool) -> io::IoResult<()> {
let sp = rsp.span();
let ss = cm.span_to_string(sp);
let lines = cm.span_to_lines(sp);
// the span)
let span_end = Span { lo: sp.hi, hi: sp.hi, expn_info: sp.expn_info};
let ses = cm.span_to_string(span_end);
- try!(print_diagnostic(dst, ses.as_slice(), lvl, msg));
+ try!(print_diagnostic(dst, ses.as_slice(), lvl, msg, code));
if rsp.is_full_span() {
try!(custom_highlight_lines(dst, cm, sp, lvl, lines));
}
} else {
- try!(print_diagnostic(dst, ss.as_slice(), lvl, msg));
+ try!(print_diagnostic(dst, ss.as_slice(), lvl, msg, code));
if rsp.is_full_span() {
try!(highlight_lines(dst, cm, sp, lvl, lines));
}
try!(print_diagnostic(w, ss.as_slice(), Note,
format!("in expansion of {}{}{}", pre,
ei.callee.name,
- post).as_slice()));
+ post).as_slice(), None));
let ss = cm.span_to_string(ei.call_site);
- try!(print_diagnostic(w, ss.as_slice(), Note, "expansion site"));
+ try!(print_diagnostic(w, ss.as_slice(), Note, "expansion site", None));
try!(print_macro_backtrace(w, cm, ei.call_site));
}
Ok(())
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![macro_escape]
+
+// NOTE: remove after next snapshot
+#[cfg(stage0)]
+#[macro_export]
+macro_rules! __register_diagnostic(
+ ($code:tt, $description:tt) => ();
+ ($code:tt) => ()
+)
+
+#[macro_export]
+macro_rules! register_diagnostic(
+ ($code:tt, $description:tt) => (__register_diagnostic!($code, $description));
+ ($code:tt) => (__register_diagnostic!($code))
+)
+
+// NOTE: remove after next snapshot
+#[cfg(stage0)]
+#[macro_export]
+macro_rules! __build_diagnostic_array(
+ ($name:ident) => {
+ pub static $name: [(&'static str, &'static str), ..0] = [];
+ }
+)
+
+// NOTE: remove after next snapshot
+#[cfg(stage0)]
+#[macro_export]
+macro_rules! __diagnostic_used(
+ ($code:ident) => {
+ ()
+ }
+)
+
+#[macro_export]
+macro_rules! span_err(
+ ($session:expr, $span:expr, $code:ident, $($arg:expr),*) => ({
+ __diagnostic_used!($code);
+ ($session).span_err_with_code($span, format!($($arg),*).as_slice(), stringify!($code))
+ })
+)
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::gc::Gc;
+use ast;
+use ast::{Ident, Name, TokenTree};
+use codemap::Span;
+use ext::base::{ExtCtxt, MacExpr, MacItem, MacResult};
+use ext::build::AstBuilder;
+use parse::token;
+
+local_data_key!(registered_diagnostics: RefCell<HashMap<Name, Option<Name>>>)
+local_data_key!(used_diagnostics: RefCell<HashMap<Name, Span>>)
+
+fn with_registered_diagnostics<T>(f: |&mut HashMap<Name, Option<Name>>| -> T) -> T {
+ match registered_diagnostics.get() {
+ Some(cell) => f(cell.borrow_mut().deref_mut()),
+ None => {
+ let mut map = HashMap::new();
+ let value = f(&mut map);
+ registered_diagnostics.replace(Some(RefCell::new(map)));
+ value
+ }
+ }
+}
+
+fn with_used_diagnostics<T>(f: |&mut HashMap<Name, Span>| -> T) -> T {
+ match used_diagnostics.get() {
+ Some(cell) => f(cell.borrow_mut().deref_mut()),
+ None => {
+ let mut map = HashMap::new();
+ let value = f(&mut map);
+ used_diagnostics.replace(Some(RefCell::new(map)));
+ value
+ }
+ }
+}
+
+pub fn expand_diagnostic_used(ecx: &mut ExtCtxt, span: Span,
+ token_tree: &[TokenTree]) -> Box<MacResult> {
+ let code = match token_tree {
+ [ast::TTTok(_, token::IDENT(code, _))] => code,
+ _ => unreachable!()
+ };
+ with_registered_diagnostics(|diagnostics| {
+ if !diagnostics.contains_key(&code.name) {
+ ecx.span_err(span, format!(
+ "unknown diagnostic code {}", token::get_ident(code).get()
+ ).as_slice());
+ }
+ ()
+ });
+ with_used_diagnostics(|diagnostics| {
+ match diagnostics.swap(code.name, span) {
+ Some(previous_span) => {
+ ecx.span_warn(span, format!(
+ "diagnostic code {} already used", token::get_ident(code).get()
+ ).as_slice());
+ ecx.span_note(previous_span, "previous invocation");
+ },
+ None => ()
+ }
+ ()
+ });
+ MacExpr::new(quote_expr!(ecx, ()))
+}
+
+pub fn expand_register_diagnostic(ecx: &mut ExtCtxt, span: Span,
+ token_tree: &[TokenTree]) -> Box<MacResult> {
+ let (code, description) = match token_tree {
+ [ast::TTTok(_, token::IDENT(ref code, _))] => {
+ (code, None)
+ },
+ [ast::TTTok(_, token::IDENT(ref code, _)),
+ ast::TTTok(_, token::COMMA),
+ ast::TTTok(_, token::LIT_STR_RAW(description, _))] => {
+ (code, Some(description))
+ }
+ _ => unreachable!()
+ };
+ with_registered_diagnostics(|diagnostics| {
+ if !diagnostics.insert(code.name, description) {
+ ecx.span_err(span, format!(
+ "diagnostic code {} already registered", token::get_ident(*code).get()
+ ).as_slice());
+ }
+ });
+ let sym = Ident::new(token::gensym((
+ "__register_diagnostic_".to_string() + token::get_ident(*code).get()
+ ).as_slice()));
+ MacItem::new(quote_item!(ecx, mod $sym {}).unwrap())
+}
+
+pub fn expand_build_diagnostic_array(ecx: &mut ExtCtxt, span: Span,
+ token_tree: &[TokenTree]) -> Box<MacResult> {
+ let name = match token_tree {
+ [ast::TTTok(_, token::IDENT(ref name, _))] => name,
+ _ => unreachable!()
+ };
+
+ let (count, expr) = with_used_diagnostics(|diagnostics_in_use| {
+ with_registered_diagnostics(|diagnostics| {
+ let descriptions: Vec<Gc<ast::Expr>> = diagnostics
+ .iter().filter_map(|(code, description)| {
+ if !diagnostics_in_use.contains_key(code) {
+ ecx.span_warn(span, format!(
+ "diagnostic code {} never used", token::get_name(*code).get()
+ ).as_slice());
+ }
+ description.map(|description| {
+ ecx.expr_tuple(span, vec![
+ ecx.expr_str(span, token::get_name(*code)),
+ ecx.expr_str(span, token::get_name(description))
+ ])
+ })
+ }).collect();
+ (descriptions.len(), ecx.expr_vec(span, descriptions))
+ })
+ });
+ MacItem::new(quote_item!(ecx,
+ pub static $name: [(&'static str, &'static str), ..$count] = $expr;
+ ).unwrap())
+}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::HashMap;
+
+pub struct Registry {
+ descriptions: HashMap<&'static str, &'static str>
+}
+
+impl Registry {
+ pub fn new(descriptions: &[(&'static str, &'static str)]) -> Registry {
+ Registry { descriptions: descriptions.iter().map(|&tuple| tuple).collect() }
+ }
+
+ pub fn find_description(&self, code: &str) -> Option<&'static str> {
+ self.descriptions.find_equiv(&code).map(|desc| *desc)
+ }
+}
fn expr_some(&self, sp: Span, expr: Gc<ast::Expr>) -> Gc<ast::Expr>;
fn expr_none(&self, sp: Span) -> Gc<ast::Expr>;
+ fn expr_tuple(&self, sp: Span, exprs: Vec<Gc<ast::Expr>>) -> Gc<ast::Expr>;
+
fn expr_fail(&self, span: Span, msg: InternedString) -> Gc<ast::Expr>;
fn expr_unreachable(&self, span: Span) -> Gc<ast::Expr>;
self.expr_path(none)
}
+ fn expr_tuple(&self, sp: Span, exprs: Vec<Gc<ast::Expr>>) -> Gc<ast::Expr> {
+ self.expr(sp, ast::ExprTup(exprs))
+ }
+
fn expr_fail(&self, span: Span, msg: InternedString) -> Gc<ast::Expr> {
let loc = self.codemap().lookup_char_pos(span.lo);
self.expr_call_global(
args: Vec::new(),
ret_ty: Self,
attributes: attrs,
- const_nonmatching: false,
combine_substructure: combine_substructure(|c, s, sub| {
cs_clone("Clone", c, s, sub)
}),
ctor_ident = variant.node.name;
all_fields = af;
},
- EnumNonMatching(..) => {
+ EnumNonMatchingCollapsed (..) => {
cx.span_bug(trait_span,
format!("non-matching enum variants in \
`deriving({})`",
args: vec!(borrowed_self()),
ret_ty: Literal(Path::new(vec!("bool"))),
attributes: attrs,
- const_nonmatching: true,
combine_substructure: combine_substructure(|a, b, c| {
$f(a, b, c)
})
args: vec!(borrowed_self()),
ret_ty: Literal(Path::new(vec!("bool"))),
attributes: attrs,
- const_nonmatching: false,
combine_substructure: combine_substructure(|cx, span, substr| {
cs_op($op, $equal, cx, span, substr)
})
args: vec![borrowed_self()],
ret_ty: ret_ty,
attributes: attrs,
- const_nonmatching: false,
combine_substructure: combine_substructure(|cx, span, substr| {
cs_partial_cmp(cx, span, substr)
})
trait_def.expand(cx, mitem, item, push)
}
-pub fn some_ordering_const(cx: &mut ExtCtxt, span: Span, cnst: Ordering) -> Gc<ast::Expr> {
- let cnst = match cnst {
- Less => "Less",
- Equal => "Equal",
- Greater => "Greater"
+pub enum OrderingOp {
+ PartialCmpOp, LtOp, LeOp, GtOp, GeOp,
+}
+
+pub fn some_ordering_collapsed(cx: &mut ExtCtxt,
+ span: Span,
+ op: OrderingOp,
+ self_arg_tags: &[ast::Ident]) -> Gc<ast::Expr> {
+ let lft = cx.expr_ident(span, self_arg_tags[0]);
+ let rgt = cx.expr_addr_of(span, cx.expr_ident(span, self_arg_tags[1]));
+ let op_str = match op {
+ PartialCmpOp => "partial_cmp",
+ LtOp => "lt", LeOp => "le",
+ GtOp => "gt", GeOp => "ge",
};
- let ordering = cx.path_global(span,
- vec!(cx.ident_of("std"),
- cx.ident_of("cmp"),
- cx.ident_of(cnst)));
- let ordering = cx.expr_path(ordering);
- cx.expr_some(span, ordering)
+ cx.expr_method_call(span, lft, cx.ident_of(op_str), vec![rgt])
}
pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span,
substr: &Substructure) -> Gc<Expr> {
let test_id = cx.ident_of("__test");
- let equals_expr = some_ordering_const(cx, span, Equal);
+ let ordering = cx.path_global(span,
+ vec!(cx.ident_of("std"),
+ cx.ident_of("cmp"),
+ cx.ident_of("Equal")));
+ let ordering = cx.expr_path(ordering);
+ let equals_expr = cx.expr_some(span, ordering);
/*
Builds:
cx.expr_block(cx.block(span, vec!(assign), Some(if_)))
},
equals_expr.clone(),
- |cx, span, list, _| {
- match list {
- // an earlier nonmatching variant is Less than a
- // later one.
- [(self_var, _, _), (other_var, _, _)] =>
- some_ordering_const(cx, span, self_var.cmp(&other_var)),
- _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(Ord)`")
+ |cx, span, (self_args, tag_tuple), _non_self_args| {
+ if self_args.len() != 2 {
+ cx.span_bug(span, "not exactly 2 arguments in `deriving(Ord)`")
+ } else {
+ some_ordering_collapsed(cx, span, PartialCmpOp, tag_tuple)
}
},
cx, span, substr)
cx.expr_binary(span, ast::BiOr, cmp, and)
},
cx.expr_bool(span, equal),
- |cx, span, args, _| {
- // nonmatching enums, order by the order the variants are
- // written
- match args {
- [(self_var, _, _),
- (other_var, _, _)] =>
- cx.expr_bool(span,
- if less {
- self_var < other_var
- } else {
- self_var > other_var
- }),
- _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(Ord)`")
+ |cx, span, (self_args, tag_tuple), _non_self_args| {
+ if self_args.len() != 2 {
+ cx.span_bug(span, "not exactly 2 arguments in `deriving(Ord)`")
+ } else {
+ let op = match (less, equal) {
+ (true, true) => LeOp, (true, false) => LtOp,
+ (false, true) => GeOp, (false, false) => GtOp,
+ };
+ some_ordering_collapsed(cx, span, op, tag_tuple)
}
},
cx, span, substr)
args: vec!(),
ret_ty: nil_ty(),
attributes: attrs,
- const_nonmatching: true,
combine_substructure: combine_substructure(|a, b, c| {
cs_total_eq_assert(a, b, c)
})
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
-use std::cmp::{Ordering, Equal, Less, Greater};
use std::gc::Gc;
pub fn expand_deriving_totalord(cx: &mut ExtCtxt,
args: vec!(borrowed_self()),
ret_ty: Literal(Path::new(vec!("std", "cmp", "Ordering"))),
attributes: attrs,
- const_nonmatching: false,
combine_substructure: combine_substructure(|a, b, c| {
cs_cmp(a, b, c)
}),
}
-pub fn ordering_const(cx: &mut ExtCtxt, span: Span, cnst: Ordering) -> ast::Path {
- let cnst = match cnst {
- Less => "Less",
- Equal => "Equal",
- Greater => "Greater"
- };
- cx.path_global(span,
- vec!(cx.ident_of("std"),
- cx.ident_of("cmp"),
- cx.ident_of(cnst)))
+pub fn ordering_collapsed(cx: &mut ExtCtxt,
+ span: Span,
+ self_arg_tags: &[ast::Ident]) -> Gc<ast::Expr> {
+ let lft = cx.expr_ident(span, self_arg_tags[0]);
+ let rgt = cx.expr_addr_of(span, cx.expr_ident(span, self_arg_tags[1]));
+ cx.expr_method_call(span, lft, cx.ident_of("cmp"), vec![rgt])
}
pub fn cs_cmp(cx: &mut ExtCtxt, span: Span,
substr: &Substructure) -> Gc<Expr> {
let test_id = cx.ident_of("__test");
- let equals_path = ordering_const(cx, span, Equal);
+ let equals_path = cx.path_global(span,
+ vec!(cx.ident_of("std"),
+ cx.ident_of("cmp"),
+ cx.ident_of("Equal")));
/*
Builds:
cx.expr_block(cx.block(span, vec!(assign), Some(if_)))
},
cx.expr_path(equals_path.clone()),
- |cx, span, list, _| {
- match list {
- // an earlier nonmatching variant is Less than a
- // later one.
- [(self_var, _, _),
- (other_var, _, _)] => {
- let order = ordering_const(cx, span, self_var.cmp(&other_var));
- cx.expr_path(order)
- }
- _ => cx.span_bug(span, "not exactly 2 arguments in `deriving(Ord)`")
+ |cx, span, (self_args, tag_tuple), _non_self_args| {
+ if self_args.len() != 2 {
+ cx.span_bug(span, "not exactly 2 arguments in `deriving(TotalOrd)`")
+ } else {
+ ordering_collapsed(cx, span, tag_tuple)
}
},
cx, span, substr)
vec!(box Self,
box Literal(Path::new_local("__E"))), true)),
attributes: Vec::new(),
- const_nonmatching: true,
combine_substructure: combine_substructure(|a, b, c| {
decodable_substructure(a, b, c)
}),
args: Vec::new(),
ret_ty: Self,
attributes: attrs,
- const_nonmatching: false,
combine_substructure: combine_substructure(|a, b, c| {
default_substructure(a, b, c)
})
box Literal(Path::new_local("__E"))),
true)),
attributes: Vec::new(),
- const_nonmatching: true,
combine_substructure: combine_substructure(|a, b, c| {
encodable_substructure(a, b, c)
}),
//! `struct T(int, char)`).
//! - `EnumMatching`, when `Self` is an enum and all the arguments are the
//! same variant of the enum (e.g. `Some(1)`, `Some(3)` and `Some(4)`)
-//! - `EnumNonMatching` when `Self` is an enum and the arguments are not
-//! the same variant (e.g. `None`, `Some(1)` and `None`). If
-//! `const_nonmatching` is true, this will contain an empty list.
+//! - `EnumNonMatchingCollapsed` when `Self` is an enum and the arguments
+//! are not the same variant (e.g. `None`, `Some(1)` and `None`).
//! - `StaticEnum` and `StaticStruct` for static methods, where the type
//! being derived upon is either an enum or struct respectively. (Any
//! argument with type Self is just grouped among the non-self
//! arguments.)
//!
//! In the first two cases, the values from the corresponding fields in
-//! all the arguments are grouped together. In the `EnumNonMatching` case
+//! all the arguments are grouped together. For `EnumNonMatchingCollapsed`
//! this isn't possible (different variants have different fields), so the
-//! fields are grouped by which argument they come from. There are no
+//! fields are inaccessible. (Previous versions of the deriving infrastructure
+//! had a way to expand into code that could access them, at the cost of
+//! generating exponential amounts of code; see issue #15375). There are no
//! fields with values in the static cases, so these are treated entirely
//! differently.
//!
//! For `C0(a)` and `C1 {x}` ,
//!
//! ~~~text
-//! EnumNonMatching(~[(0, <ast::Variant for B0>,
-//! ~[(<span of int>, None, <expr for &a>)]),
-//! (1, <ast::Variant for B1>,
-//! ~[(<span of x>, Some(<ident of x>),
-//! <expr for &other.x>)])])
+//! EnumNonMatchingCollapsed(
+//! ~[<ident of self>, <ident of __arg_1>],
+//! &[<ast::Variant for C0>, <ast::Variant for C1>],
+//! &[<ident for self index value>, <ident of __arg_1 index value>])
//! ~~~
//!
-//! (and vice versa, but with the order of the outermost list flipped.)
+//! It is the same for when the arguments are flipped to `C1 {x}` and
+//! `C0(a)`; the only difference is what the values of the identifiers
+//! <ident for self index value> and <ident of __arg_1 index value> will
+//! be in the generated code.
+//!
+//! `EnumNonMatchingCollapsed` deliberately provides far less information
+//! than is generally available for a given pair of variants; see #15375
+//! for discussion.
//!
//! ## Static
//!
pub attributes: Vec<ast::Attribute>,
- /// if the value of the nonmatching enums is independent of the
- /// actual enum variants, i.e. can use _ => .. match.
- pub const_nonmatching: bool,
-
pub combine_substructure: RefCell<CombineSubstructureFunc<'a>>,
}
EnumMatching(uint, &'a ast::Variant, Vec<FieldInfo>),
/**
- non-matching variants of the enum, [(variant index, ast::Variant,
- [field span, field ident, fields])] \(i.e. all fields for self are in the
- first tuple, for other1 are in the second tuple, etc.)
+ non-matching variants of the enum, but with all state hidden from
+ the consequent code. The first component holds Idents for all of
+ the Self arguments; the second component is a slice of all of the
+ variants for the enum itself, and the third component is a list of
+ Idents bound to the variant index values for each of the actual
+ input Self arguments.
*/
- EnumNonMatching(&'a [(uint, P<ast::Variant>,
- Vec<(Span, Option<Ident>, Gc<Expr>)>)]),
+ EnumNonMatchingCollapsed(Vec<Ident>, &'a [Gc<ast::Variant>], &'a [Ident]),
/// A static method where Self is a struct.
StaticStruct(&'a ast::StructDef, StaticFields),
|&mut ExtCtxt, Span, &Substructure|: 'a -> Gc<Expr>;
/**
-Deal with non-matching enum variants, the arguments are a list
-representing each variant: (variant index, ast::Variant instance,
-[variant fields]), and a list of the nonself args of the type
+Deal with non-matching enum variants. The tuple is a list of
+identifiers (one for each Self argument, which could be any of the
+variants since they have been collapsed together) and the identifiers
+holding the variant index value for each of the Self arguments. The
+last argument is all the non-Self args of the method being derived.
*/
-pub type EnumNonMatchFunc<'a> =
+pub type EnumNonMatchCollapsedFunc<'a> =
|&mut ExtCtxt,
Span,
- &[(uint, P<ast::Variant>, Vec<(Span, Option<Ident>, Gc<Expr>)>)],
+ (&[Ident], &[Ident]),
&[Gc<Expr>]|: 'a
-> Gc<Expr>;
}
}
+fn variant_to_pat(cx: &mut ExtCtxt, sp: Span, variant: &ast::Variant)
+ -> Gc<ast::Pat> {
+ let ident = cx.path_ident(sp, variant.node.name);
+ cx.pat(sp, match variant.node.kind {
+ ast::TupleVariantKind(..) => ast::PatEnum(ident, None),
+ ast::StructVariantKind(..) => ast::PatStruct(ident, Vec::new(), true),
+ })
+}
+
impl<'a> MethodDef<'a> {
fn call_substructure_method(&self,
cx: &mut ExtCtxt,
~~~
#[deriving(PartialEq)]
enum A {
- A1
+ A1,
A2(int)
}
- // is equivalent to (with const_nonmatching == false)
+ // is equivalent to
impl PartialEq for A {
- fn eq(&self, __arg_1: &A) {
- match *self {
- A1 => match *__arg_1 {
- A1 => true
- A2(ref __arg_1_1) => false
- },
- A2(self_1) => match *__arg_1 {
- A1 => false,
- A2(ref __arg_1_1) => self_1.eq(__arg_1_1)
+ fn eq(&self, __arg_1: &A) -> ::bool {
+ match (&*self, &*__arg_1) {
+ (&A1, &A1) => true,
+ (&A2(ref __self_0),
+ &A2(ref __arg_1_0)) => (*__self_0).eq(&(*__arg_1_0)),
+ _ => {
+ let __self_vi = match *self { A1(..) => 0u, A2(..) => 1u };
+ let __arg_1_vi = match *__arg_1 { A1(..) => 0u, A2(..) => 1u };
+ false
}
}
}
}
~~~
+
+ (Of course `__self_vi` and `__arg_1_vi` are unused for
+ `PartialEq`, and those subcomputations will hopefully be removed
+ as their results are unused. The point of `__self_vi` and
+ `__arg_1_vi` is for `PartialOrd`; see #15503.)
*/
fn expand_enum_method_body(&self,
cx: &mut ExtCtxt,
self_args: &[Gc<Expr>],
nonself_args: &[Gc<Expr>])
-> Gc<Expr> {
- let mut matches = Vec::new();
- self.build_enum_match(cx, trait_, enum_def, type_ident,
- self_args, nonself_args,
- None, &mut matches, 0)
+ self.build_enum_match_tuple(
+ cx, trait_, enum_def, type_ident, self_args, nonself_args)
}
/**
- Creates the nested matches for an enum definition recursively, i.e.
-
- ~~~text
- match self {
- Variant1 => match other { Variant1 => matching, Variant2 => nonmatching, ... },
- Variant2 => match other { Variant1 => nonmatching, Variant2 => matching, ... },
- ...
+ Creates a match for a tuple of all `self_args`, where either all
+ variants match, or it falls into a catch-all for when one variant
+ does not match.
+
+ There are N + 1 cases because is a case for each of the N
+ variants where all of the variants match, and one catch-all for
+ when one does not match.
+
+ The catch-all handler is provided access the variant index values
+ for each of the self-args, carried in precomputed variables. (Nota
+ bene: the variant index values are not necessarily the
+ discriminant values. See issue #15523.)
+
+ ~~~text
+ match (this, that, ...) {
+ (Variant1, Variant1, Variant1) => ... // delegate Matching on Variant1
+ (Variant2, Variant2, Variant2) => ... // delegate Matching on Variant2
+ ...
+ _ => {
+ let __this_vi = match this { Variant1 => 0u, Variant2 => 1u, ... };
+ let __that_vi = match that { Variant1 => 0u, Variant2 => 1u, ... };
+ ... // catch-all remainder can inspect above variant index values.
+ }
}
- ~~~
-
- It acts in the most naive way, so every branch (and subbranch,
- subsubbranch, etc) exists, not just the ones where all the variants in
- the tree are the same. Hopefully the optimisers get rid of any
- repetition, otherwise derived methods with many Self arguments will be
- exponentially large.
-
- `matching` is Some(n) if all branches in the tree above the
- current position are variant `n`, `None` otherwise (including on
- the first call).
+ ~~~
*/
- fn build_enum_match(&self,
- cx: &mut ExtCtxt,
- trait_: &TraitDef,
- enum_def: &EnumDef,
- type_ident: Ident,
- self_args: &[Gc<Expr>],
- nonself_args: &[Gc<Expr>],
- matching: Option<uint>,
- matches_so_far: &mut Vec<(uint, P<ast::Variant>,
- Vec<(Span, Option<Ident>, Gc<Expr>)>)> ,
- match_count: uint) -> Gc<Expr> {
- if match_count == self_args.len() {
- // we've matched against all arguments, so make the final
- // expression at the bottom of the match tree
- if matches_so_far.len() == 0 {
- cx.span_bug(trait_.span,
- "no self match on an enum in \
- generic `deriving`");
- }
-
- // `ref` inside let matches is buggy. Causes havoc with rusc.
- // let (variant_index, ref self_vec) = matches_so_far[0];
- let (variant, self_vec) = match matches_so_far.get(0) {
- &(_, v, ref s) => (v, s)
- };
-
- // we currently have a vec of vecs, where each
- // subvec is the fields of one of the arguments,
- // but if the variants all match, we want this as
- // vec of tuples, where each tuple represents a
- // field.
-
- // most arms don't have matching variants, so do a
- // quick check to see if they match (even though
- // this means iterating twice) instead of being
- // optimistic and doing a pile of allocations etc.
- let substructure = match matching {
- Some(variant_index) => {
- let mut enum_matching_fields = Vec::from_elem(self_vec.len(), Vec::new());
-
- for triple in matches_so_far.tail().iter() {
- match triple {
- &(_, _, ref other_fields) => {
- for (i, &(_, _, e)) in other_fields.iter().enumerate() {
- enum_matching_fields.get_mut(i).push(e);
- }
- }
- }
- }
- let field_tuples =
- self_vec.iter()
- .zip(enum_matching_fields.iter())
- .map(|(&(span, id, self_f), other)| {
- FieldInfo {
- span: span,
- name: id,
- self_: self_f,
- other: (*other).clone()
- }
- }).collect();
- EnumMatching(variant_index, &*variant, field_tuples)
- }
- None => {
- EnumNonMatching(matches_so_far.as_slice())
+ fn build_enum_match_tuple(
+ &self,
+ cx: &mut ExtCtxt,
+ trait_: &TraitDef,
+ enum_def: &EnumDef,
+ type_ident: Ident,
+ self_args: &[Gc<Expr>],
+ nonself_args: &[Gc<Expr>]) -> Gc<Expr> {
+
+ let sp = trait_.span;
+ let variants = &enum_def.variants;
+
+ let self_arg_names = self_args.iter().enumerate()
+ .map(|(arg_count, _self_arg)| {
+ if arg_count == 0 {
+ "__self".to_string()
+ } else {
+ format!("__arg_{}", arg_count)
}
- };
- self.call_substructure_method(cx, trait_, type_ident,
- self_args, nonself_args,
- &substructure)
+ })
+ .collect::<Vec<String>>();
+
+ let self_arg_idents = self_arg_names.iter()
+ .map(|name|cx.ident_of(name.as_slice()))
+ .collect::<Vec<ast::Ident>>();
+
+ // The `vi_idents` will be bound, solely in the catch-all, to
+ // a series of let statements mapping each self_arg to a uint
+ // corresponding to its variant index.
+ let vi_idents : Vec<ast::Ident> = self_arg_names.iter()
+ .map(|name| { let vi_suffix = format!("{:s}_vi", name.as_slice());
+ cx.ident_of(vi_suffix.as_slice()) })
+ .collect::<Vec<ast::Ident>>();
+
+ // Builds, via callback to call_substructure_method, the
+ // delegated expression that handles the catch-all case,
+ // using `__variants_tuple` to drive logic if necessary.
+ let catch_all_substructure = EnumNonMatchingCollapsed(
+ self_arg_idents, variants.as_slice(), vi_idents.as_slice());
+
+ // These arms are of the form:
+ // (Variant1, Variant1, ...) => Body1
+ // (Variant2, Variant2, ...) => Body2
+ // ...
+ // where each tuple has length = self_args.len()
+ let mut match_arms : Vec<ast::Arm> = variants.iter().enumerate()
+ .map(|(index, &variant)| {
+
+ // These self_pats have form Variant1, Variant2, ...
+ let self_pats : Vec<(Gc<ast::Pat>,
+ Vec<(Span, Option<Ident>, Gc<Expr>)>)>;
+ self_pats = self_arg_names.iter()
+ .map(|self_arg_name|
+ trait_.create_enum_variant_pattern(
+ cx, &*variant, self_arg_name.as_slice(),
+ ast::MutImmutable))
+ .collect();
+
+ // A single arm has form (&VariantK, &VariantK, ...) => BodyK
+ // (see "Final wrinkle" note below for why.)
+ let subpats = self_pats.iter()
+ .map(|&(p, ref _idents)| cx.pat(sp, ast::PatRegion(p)))
+ .collect::<Vec<Gc<ast::Pat>>>();
+
+ // Here is the pat = `(&VariantK, &VariantK, ...)`
+ let single_pat = cx.pat(sp, ast::PatTup(subpats));
+
+ // For the BodyK, we need to delegate to our caller,
+ // passing it an EnumMatching to indicate which case
+ // we are in.
+
+ // All of the Self args have the same variant in these
+ // cases. So we transpose the info in self_pats to
+ // gather the getter expressions together, in the form
+ // that EnumMatching expects.
+
+ // The transposition is driven by walking across the
+ // arg fields of the variant for the first self pat.
+ let &(_, ref self_arg_fields) = self_pats.get(0);
+
+ let field_tuples : Vec<FieldInfo>;
+
+ field_tuples = self_arg_fields.iter().enumerate()
+ // For each arg field of self, pull out its getter expr ...
+ .map(|(field_index, &(sp, opt_ident, self_getter_expr))| {
+ // ... but FieldInfo also wants getter expr
+ // for matching other arguments of Self type;
+ // so walk across the *other* self_pats and
+ // pull out getter for same field in each of
+ // them (using `field_index` tracked above).
+ // That is the heart of the transposition.
+ let others = self_pats.tail().iter()
+ .map(|&(_pat, ref fields)| {
+
+ let &(_, _opt_ident, other_getter_expr) =
+ fields.get(field_index);
+
+ // All Self args have same variant, so
+ // opt_idents are the same. (Assert
+ // here to make it self-evident that
+ // it is okay to ignore `_opt_ident`.)
+ assert!(opt_ident == _opt_ident);
+
+ other_getter_expr
+ }).collect::<Vec<Gc<Expr>>>();
+
+ FieldInfo { span: sp,
+ name: opt_ident,
+ self_: self_getter_expr,
+ other: others,
+ }
+ }).collect::<Vec<FieldInfo>>();
+
+ // Now, for some given VariantK, we have built up
+ // expressions for referencing every field of every
+ // Self arg, assuming all are instances of VariantK.
+ // Build up code associated with such a case.
+ let substructure = EnumMatching(index, variant, field_tuples);
+ let arm_expr = self.call_substructure_method(
+ cx, trait_, type_ident, self_args, nonself_args,
+ &substructure);
+
+ cx.arm(sp, vec![single_pat], arm_expr)
+ }).collect();
- } else { // there are still matches to create
- let current_match_str = if match_count == 0 {
- "__self".to_string()
- } else {
- format!("__arg_{}", match_count)
- };
+ // We will usually need the catch-all after matching the
+ // tuples `(VariantK, VariantK, ...)` for each VariantK of the
+ // enum. But:
+ //
+ // * when there is only one Self arg, the arms above suffice
+ // (and the deriving we call back into may not be prepared to
+ // handle EnumNonMatchCollapsed), and,
+ //
+ // * when the enum has only one variant, the single arm that
+ // is already present always suffices.
+ //
+ // * In either of the two cases above, if we *did* add a
+ // catch-all `_` match, it would trigger the
+ // unreachable-pattern error.
+ //
+ if variants.len() > 1 && self_args.len() > 1 {
+ let arms : Vec<ast::Arm> = variants.iter().enumerate()
+ .map(|(index, &variant)| {
+ let pat = variant_to_pat(cx, sp, &*variant);
+ let lit = ast::LitUint(index as u64, ast::TyU);
+ cx.arm(sp, vec![pat], cx.expr_lit(sp, lit))
+ }).collect();
- let mut arms = Vec::new();
-
- // the code for nonmatching variants only matters when
- // we've seen at least one other variant already
- if self.const_nonmatching && match_count > 0 {
- // make a matching-variant match, and a _ match.
- let index = match matching {
- Some(i) => i,
- None => cx.span_bug(trait_.span,
- "non-matching variants when required to \
- be matching in generic `deriving`")
- };
-
- // matching-variant match
- let variant = *enum_def.variants.get(index);
- let (pattern, idents) = trait_.create_enum_variant_pattern(
- cx,
- &*variant,
- current_match_str.as_slice(),
- ast::MutImmutable);
-
- matches_so_far.push((index, variant, idents));
- let arm_expr = self.build_enum_match(cx,
- trait_,
- enum_def,
- type_ident,
- self_args, nonself_args,
- matching,
- matches_so_far,
- match_count + 1);
- matches_so_far.pop().unwrap();
- arms.push(cx.arm(trait_.span, vec!( pattern ), arm_expr));
-
- if enum_def.variants.len() > 1 {
- let e = &EnumNonMatching(&[]);
- let wild_expr = self.call_substructure_method(cx, trait_, type_ident,
- self_args, nonself_args,
- e);
- let wild_arm = cx.arm(
- trait_.span,
- vec!( cx.pat_wild(trait_.span) ),
- wild_expr);
- arms.push(wild_arm);
- }
- } else {
- // create an arm matching on each variant
- for (index, &variant) in enum_def.variants.iter().enumerate() {
- let (pattern, idents) =
- trait_.create_enum_variant_pattern(
- cx,
- &*variant,
- current_match_str.as_slice(),
- ast::MutImmutable);
-
- matches_so_far.push((index, variant, idents));
- let new_matching =
- match matching {
- _ if match_count == 0 => Some(index),
- Some(i) if index == i => Some(i),
- _ => None
- };
- let arm_expr = self.build_enum_match(cx,
- trait_,
- enum_def,
- type_ident,
- self_args, nonself_args,
- new_matching,
- matches_so_far,
- match_count + 1);
- matches_so_far.pop().unwrap();
-
- let arm = cx.arm(trait_.span, vec!( pattern ), arm_expr);
- arms.push(arm);
- }
+ // Build a series of let statements mapping each self_arg
+ // to a uint corresponding to its variant index.
+ // i.e. for `enum E<T> { A, B(1), C(T, T) }`, and a deriving
+ // with three Self args, builds three statements:
+ //
+ // ```
+ // let __self0_vi = match self {
+ // A => 0u, B(..) => 1u, C(..) => 2u
+ // };
+ // let __self1_vi = match __arg1 {
+ // A => 0u, B(..) => 1u, C(..) => 2u
+ // };
+ // let __self2_vi = match __arg2 {
+ // A => 0u, B(..) => 1u, C(..) => 2u
+ // };
+ // ```
+ let mut index_let_stmts : Vec<Gc<ast::Stmt>> = Vec::new();
+ for (&ident, &self_arg) in vi_idents.iter().zip(self_args.iter()) {
+ let variant_idx = cx.expr_match(sp, self_arg, arms.clone());
+ let let_stmt = cx.stmt_let(sp, false, ident, variant_idx);
+ index_let_stmts.push(let_stmt);
}
- // match foo { arm, arm, arm, ... }
- cx.expr_match(trait_.span, self_args[match_count], arms)
+ let arm_expr = self.call_substructure_method(
+ cx, trait_, type_ident, self_args, nonself_args,
+ &catch_all_substructure);
+
+ // Builds the expression:
+ // {
+ // let __self0_vi = ...;
+ // let __self1_vi = ...;
+ // ...
+ // <delegated expression referring to __self0_vi, et al.>
+ // }
+ let arm_expr = cx.expr_block(
+ cx.block_all(sp, Vec::new(), index_let_stmts, Some(arm_expr)));
+
+ // Builds arm:
+ // _ => { let __self0_vi = ...;
+ // let __self1_vi = ...;
+ // ...
+ // <delegated expression as above> }
+ let catch_all_match_arm =
+ cx.arm(sp, vec![cx.pat_wild(sp)], arm_expr);
+
+ match_arms.push(catch_all_match_arm);
+
+ } else if variants.len() == 0 {
+ // As an additional wrinkle, For a zero-variant enum A,
+ // currently the compiler
+ // will accept `fn (a: &Self) { match *a { } }`
+ // but rejects `fn (a: &Self) { match (&*a,) { } }`
+ // as well as `fn (a: &Self) { match ( *a,) { } }`
+ //
+ // This means that the strategy of building up a tuple of
+ // all Self arguments fails when Self is a zero variant
+ // enum: rustc rejects the expanded program, even though
+ // the actual code tends to be impossible to execute (at
+ // least safely), according to the type system.
+ //
+ // The most expedient fix for this is to just let the
+ // code fall through to the catch-all. But even this is
+ // error-prone, since the catch-all as defined above would
+ // generate code like this:
+ //
+ // _ => { let __self0 = match *self { };
+ // let __self1 = match *__arg_0 { };
+ // <catch-all-expr> }
+ //
+ // Which is yields bindings for variables which type
+ // inference cannot resolve to unique types.
+ //
+ // One option to the above might be to add explicit type
+ // annotations. But the *only* reason to go down that path
+ // would be to try to make the expanded output consistent
+ // with the case when the number of enum variants >= 1.
+ //
+ // That just isn't worth it. In fact, trying to generate
+ // sensible code for *any* deriving on a zero-variant enum
+ // does not make sense. But at the same time, for now, we
+ // do not want to cause a compile failure just because the
+ // user happened to attach a deriving to their
+ // zero-variant enum.
+ //
+ // Instead, just generate a failing expression for the
+ // zero variant case, skipping matches and also skipping
+ // delegating back to the end user code entirely.
+ //
+ // (See also #4499 and #12609; note that some of the
+ // discussions there influence what choice we make here;
+ // e.g. if we feature-gate `match x { ... }` when x refers
+ // to an uninhabited type (e.g. a zero-variant enum or a
+ // type holding such an enum), but do not feature-gate
+ // zero-variant enums themselves, then attempting to
+ // derive Show on such a type could here generate code
+ // that needs the feature gate enabled.)
+
+ return cx.expr_unreachable(sp);
}
+
+ // Final wrinkle: the self_args are expressions that deref
+ // down to desired l-values, but we cannot actually deref
+ // them when they are fed as r-values into a tuple
+ // expression; here add a layer of borrowing, turning
+ // `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`.
+ let borrowed_self_args = self_args.iter()
+ .map(|&self_arg| cx.expr_addr_of(sp, self_arg))
+ .collect::<Vec<Gc<ast::Expr>>>();
+ let match_arg = cx.expr(sp, ast::ExprTup(borrowed_self_args));
+ cx.expr_match(sp, match_arg, match_arms)
}
fn expand_static_enum_method_body(&self,
pub fn cs_fold(use_foldl: bool,
f: |&mut ExtCtxt, Span, Gc<Expr>, Gc<Expr>, &[Gc<Expr>]| -> Gc<Expr>,
base: Gc<Expr>,
- enum_nonmatch_f: EnumNonMatchFunc,
+ enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt,
trait_span: Span,
substructure: &Substructure)
})
}
},
- EnumNonMatching(ref all_enums) => enum_nonmatch_f(cx, trait_span,
- *all_enums,
- substructure.nonself_args),
+ EnumNonMatchingCollapsed(ref all_args, _, tuple) =>
+ enum_nonmatch_f(cx, trait_span, (all_args.as_slice(), tuple),
+ substructure.nonself_args),
StaticEnum(..) | StaticStruct(..) => {
cx.span_bug(trait_span, "static function in `deriving`")
}
*/
#[inline]
pub fn cs_same_method(f: |&mut ExtCtxt, Span, Vec<Gc<Expr>>| -> Gc<Expr>,
- enum_nonmatch_f: EnumNonMatchFunc,
+ enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt,
trait_span: Span,
substructure: &Substructure)
f(cx, trait_span, called)
},
- EnumNonMatching(ref all_enums) => enum_nonmatch_f(cx, trait_span,
- *all_enums,
- substructure.nonself_args),
+ EnumNonMatchingCollapsed(ref all_self_args, _, tuple) =>
+ enum_nonmatch_f(cx, trait_span, (all_self_args.as_slice(), tuple),
+ substructure.nonself_args),
StaticEnum(..) | StaticStruct(..) => {
cx.span_bug(trait_span, "static function in `deriving`")
}
pub fn cs_same_method_fold(use_foldl: bool,
f: |&mut ExtCtxt, Span, Gc<Expr>, Gc<Expr>| -> Gc<Expr>,
base: Gc<Expr>,
- enum_nonmatch_f: EnumNonMatchFunc,
+ enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt,
trait_span: Span,
substructure: &Substructure)
*/
#[inline]
pub fn cs_binop(binop: ast::BinOp, base: Gc<Expr>,
- enum_nonmatch_f: EnumNonMatchFunc,
+ enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt, trait_span: Span,
substructure: &Substructure) -> Gc<Expr> {
cs_same_method_fold(
/// cs_binop with binop == or
#[inline]
-pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc,
+pub fn cs_or(enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt, span: Span,
substructure: &Substructure) -> Gc<Expr> {
cs_binop(ast::BiOr, cx.expr_bool(span, false),
/// cs_binop with binop == and
#[inline]
-pub fn cs_and(enum_nonmatch_f: EnumNonMatchFunc,
+pub fn cs_and(enum_nonmatch_f: EnumNonMatchCollapsedFunc,
cx: &mut ExtCtxt, span: Span,
substructure: &Substructure) -> Gc<Expr> {
cs_binop(ast::BiAnd, cx.expr_bool(span, true),
args: vec!(Ptr(box Literal(args), Borrowed(None, MutMutable))),
ret_ty: nil_ty(),
attributes: attrs,
- const_nonmatching: false,
combine_substructure: combine_substructure(|a, b, c| {
hash_substructure(a, b, c)
})
true)),
// #[inline] liable to cause code-bloat
attributes: attrs.clone(),
- const_nonmatching: false,
combine_substructure: combine_substructure(|c, s, sub| {
cs_from("i64", c, s, sub)
}),
true)),
// #[inline] liable to cause code-bloat
attributes: attrs,
- const_nonmatching: false,
combine_substructure: combine_substructure(|c, s, sub| {
cs_from("u64", c, s, sub)
}),
),
ret_ty: Self,
attributes: Vec::new(),
- const_nonmatching: false,
combine_substructure: combine_substructure(|a, b, c| {
rand_substructure(a, b, c)
})
args: vec!(fmtr),
ret_ty: Literal(Path::new(vec!("std", "fmt", "Result"))),
attributes: Vec::new(),
- const_nonmatching: false,
combine_substructure: combine_substructure(|a, b, c| {
show_substructure(a, b, c)
})
let name = match *substr.fields {
Struct(_) => substr.type_ident,
EnumMatching(_, v, _) => v.node.name,
-
- EnumNonMatching(..) | StaticStruct(..) | StaticEnum(..) => {
+ EnumNonMatchingCollapsed(..) | StaticStruct(..) | StaticEnum(..) => {
cx.span_bug(span, "nonsensical .fields in `#[deriving(Show)]`")
}
};
args: Vec::new(),
ret_ty: Self,
attributes: attrs.clone(),
- const_nonmatching: false,
combine_substructure: combine_substructure(|a, b, c| {
zero_substructure(a, b, c)
})
args: Vec::new(),
ret_ty: Literal(Path::new(vec!("bool"))),
attributes: attrs,
- const_nonmatching: false,
combine_substructure: combine_substructure(|cx, span, substr| {
cs_and(|cx, span, _, _| cx.span_bug(span,
"Non-matching enum \
None => {
fld.cx.span_err(
pth.span,
- format!("macro undefined: '{}'",
+ format!("macro undefined: '{}!'",
extnamestr.get()).as_slice());
// let compilation continue
let marked_after = match fld.extsbox.find(&extname.name) {
None => {
fld.cx.span_err(pth.span,
- format!("macro undefined: '{}'",
+ format!("macro undefined: '{}!'",
extnamestr).as_slice());
return SmallVector::zero();
}
//!
//! This API is completely unstable and subject to change.
-#![crate_id = "syntax#0.11.0"] // NOTE: remove after stage0
#![crate_name = "syntax"]
#![experimental]
#![license = "MIT/ASL2"]
#![feature(macro_rules, globs, managed_boxes, default_type_params, phase)]
#![feature(quote, unsafe_destructor)]
#![allow(deprecated)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
-
-extern crate serialize;
-extern crate term;
-#[phase(plugin, link)] extern crate log;
extern crate fmt_macros;
extern crate debug;
+#[phase(plugin, link)] extern crate log;
+extern crate serialize;
+extern crate term;
pub mod util {
pub mod interner;
pub mod small_vector;
}
+pub mod diagnostics {
+ pub mod macros;
+ pub mod plugin;
+ pub mod registry;
+}
+
pub mod syntax {
pub use ext;
pub use parse;
pub use ast;
}
-pub mod owned_slice;
-pub mod attr;
-pub mod diagnostic;
-pub mod codemap;
pub mod abi;
pub mod ast;
-pub mod ast_util;
pub mod ast_map;
-pub mod visit;
+pub mod ast_util;
+pub mod attr;
+pub mod codemap;
+pub mod crateid;
+pub mod diagnostic;
pub mod fold;
-
-
+pub mod owned_slice;
pub mod parse;
-pub mod crateid;
+pub mod visit;
pub mod print {
pub mod pp;
pub mod ext {
pub mod asm;
pub mod base;
+ pub mod build;
+ pub mod bytes;
+ pub mod cfg;
+ pub mod concat;
+ pub mod concat_idents;
+ pub mod deriving;
+ pub mod env;
pub mod expand;
-
+ pub mod fmt;
+ pub mod format;
+ pub mod log_syntax;
+ pub mod mtwt;
pub mod quote;
-
- pub mod deriving;
-
- pub mod build;
+ pub mod source_util;
+ pub mod trace_macros;
pub mod tt {
pub mod transcribe;
pub mod macro_parser;
pub mod macro_rules;
}
-
- pub mod mtwt;
-
- pub mod cfg;
- pub mod fmt;
- pub mod format;
- pub mod env;
- pub mod bytes;
- pub mod concat;
- pub mod concat_idents;
- pub mod log_syntax;
- pub mod source_util;
-
- pub mod trace_macros;
}
use std::io::util;
fn mk_sh() -> diagnostic::SpanHandler {
- let emitter = diagnostic::EmitterWriter::new(box util::NullWriter);
+ let emitter = diagnostic::EmitterWriter::new(box util::NullWriter, None);
let handler = diagnostic::mk_handler(box emitter);
diagnostic::mk_span_handler(handler, CodeMap::new())
}
pub fn new_parse_sess() -> ParseSess {
ParseSess {
- span_diagnostic: mk_span_handler(default_handler(Auto), CodeMap::new()),
+ span_diagnostic: mk_span_handler(default_handler(Auto, None), CodeMap::new()),
included_mod_stack: RefCell::new(Vec::new()),
}
}
to_string(|s| s.print_arg(arg))
}
-
-
-#[cfg(stage0)]
-pub fn to_str(f: |&mut State| -> IoResult<()>) -> String {
- let mut s = rust_printer(box MemWriter::new());
- f(&mut s).unwrap();
- eof(&mut s.s).unwrap();
- unsafe {
- // FIXME(pcwalton): A nasty function to extract the string from an `io::Writer`
- // that we "know" to be a `MemWriter` that works around the lack of checked
- // downcasts.
- let (_, wr): (uint, Box<MemWriter>) = mem::transmute_copy(&s.s.out);
- let result =
- str::from_utf8_owned(Vec::from_slice(wr.get_ref())).unwrap();
- mem::forget(wr);
- result.to_string()
- }
-}
-
-#[cfg(stage0)]
-pub fn ty_to_str(ty: &ast::Ty) -> String {
- to_str(|s| s.print_type(ty))
-}
-
-#[cfg(stage0)]
-pub fn pat_to_str(pat: &ast::Pat) -> String {
- to_str(|s| s.print_pat(pat))
-}
-
-#[cfg(stage0)]
-pub fn expr_to_str(e: &ast::Expr) -> String {
- to_str(|s| s.print_expr(e))
-}
-
-#[cfg(stage0)]
-pub fn lifetime_to_str(e: &ast::Lifetime) -> String {
- to_str(|s| s.print_lifetime(e))
-}
-
-#[cfg(stage0)]
-pub fn tt_to_str(tt: &ast::TokenTree) -> String {
- to_str(|s| s.print_tt(tt))
-}
-
-#[cfg(stage0)]
-pub fn tts_to_str(tts: &[ast::TokenTree]) -> String {
- to_str(|s| s.print_tts(tts))
-}
-
-#[cfg(stage0)]
-pub fn stmt_to_str(stmt: &ast::Stmt) -> String {
- to_str(|s| s.print_stmt(stmt))
-}
-
-#[cfg(stage0)]
-pub fn item_to_str(i: &ast::Item) -> String {
- to_str(|s| s.print_item(i))
-}
-
-#[cfg(stage0)]
-pub fn generics_to_str(generics: &ast::Generics) -> String {
- to_str(|s| s.print_generics(generics))
-}
-
-#[cfg(stage0)]
-pub fn ty_method_to_str(p: &ast::TypeMethod) -> String {
- to_str(|s| s.print_ty_method(p))
-}
-
-#[cfg(stage0)]
-pub fn method_to_str(p: &ast::Method) -> String {
- to_str(|s| s.print_method(p))
-}
-
-#[cfg(stage0)]
-pub fn fn_block_to_str(p: &ast::FnDecl) -> String {
- to_str(|s| s.print_fn_block_args(p))
-}
-
-#[cfg(stage0)]
-pub fn path_to_str(p: &ast::Path) -> String {
- to_str(|s| s.print_path(p, false))
-}
-
-#[cfg(stage0)]
-pub fn fun_to_str(decl: &ast::FnDecl, fn_style: ast::FnStyle, name: ast::Ident,
- opt_explicit_self: Option<ast::ExplicitSelf_>,
- generics: &ast::Generics) -> String {
- to_str(|s| {
- try!(s.print_fn(decl, Some(fn_style), abi::Rust,
- name, generics, opt_explicit_self, ast::Inherited));
- try!(s.end()); // Close the head box
- s.end() // Close the outer box
- })
-}
-
-#[cfg(stage0)]
-pub fn block_to_str(blk: &ast::Block) -> String {
- to_str(|s| {
- // containing cbox, will be closed by print-block at }
- try!(s.cbox(indent_unit));
- // head-ibox, will be closed by print-block after {
- try!(s.ibox(0u));
- s.print_block(blk)
- })
-}
-
-#[cfg(stage0)]
-pub fn meta_item_to_str(mi: &ast::MetaItem) -> String {
- to_str(|s| s.print_meta_item(mi))
-}
-
-#[cfg(stage0)]
-pub fn attribute_to_str(attr: &ast::Attribute) -> String {
- to_str(|s| s.print_attribute(attr))
-}
-
-#[cfg(stage0)]
-pub fn lit_to_str(l: &ast::Lit) -> String {
- to_str(|s| s.print_literal(l))
-}
-
-#[cfg(stage0)]
-pub fn explicit_self_to_str(explicit_self: ast::ExplicitSelf_) -> String {
- to_str(|s| s.print_explicit_self(explicit_self, ast::MutImmutable).map(|_| {}))
-}
-
-#[cfg(stage0)]
-pub fn variant_to_str(var: &ast::Variant) -> String {
- to_str(|s| s.print_variant(var))
-}
-
-#[cfg(stage0)]
-pub fn arg_to_str(arg: &ast::Arg) -> String {
- to_str(|s| s.print_arg(arg))
-}
-
-
-
-
pub fn visibility_qualified(vis: ast::Visibility, s: &str) -> String {
match vis {
ast::Public => format!("pub {}", s),
//! [win]: http://msdn.microsoft.com/en-us/library/windows/desktop/ms682010%28v=vs.85%29.aspx
//! [ti]: https://en.wikipedia.org/wiki/Terminfo
-#![crate_id = "term#0.11.0"] // NOTE: remove after stage0
#![crate_name = "term"]
#![experimental]
#![comment = "Simple ANSI color library"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/",
html_playground_url = "http://play.rust-lang.org/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![feature(macro_rules, phase)]
// running tests while providing a base that other test frameworks may
// build off of.
-#![crate_id = "test#0.11.0"] // NOTE: remove after stage0
-#![crate_name = "test"] // NOTE: remove after stage0
+#![crate_name = "test"]
#![experimental]
#![comment = "Rust internal test library only used by rustc"]
#![license = "MIT/ASL2"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![feature(asm, macro_rules, phase)]
//! Simple time handling.
-#![crate_id = "time#0.11.0"] // NOTE: remove after stage0
#![crate_name = "time"]
#![experimental]
html_root_url = "http://doc.rust-lang.org/0.11.0/",
html_playground_url = "http://play.rust-lang.org/")]
#![feature(phase)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#[cfg(test)] extern crate debug;
#[cfg(test)] #[phase(plugin, link)] extern crate log;
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+ Functions for computing canonical and compatible decompositions
+ for Unicode characters.
+ */
+
+use core::option::{Option, Some, None};
+use core::slice::ImmutableVector;
+use tables::normalization::{canonical_table, compatibility_table};
+
+fn bsearch_table(c: char, r: &'static [(char, &'static [char])]) -> Option<&'static [char]> {
+ use core::cmp::{Equal, Less, Greater};
+ match r.bsearch(|&(val, _)| {
+ if c == val { Equal }
+ else if val < c { Less }
+ else { Greater }
+ }) {
+ Some(idx) => {
+ let (_, result) = r[idx];
+ Some(result)
+ }
+ None => None
+ }
+}
+
+/// Compute canonical Unicode decomposition for character
+pub fn decompose_canonical(c: char, i: |char|) { d(c, i, false); }
+
+/// Compute canonical or compatible Unicode decomposition for character
+pub fn decompose_compatible(c: char, i: |char|) { d(c, i, true); }
+
+fn d(c: char, i: |char|, k: bool) {
+ use core::iter::Iterator;
+
+ // 7-bit ASCII never decomposes
+ if c <= '\x7f' { i(c); return; }
+
+ // Perform decomposition for Hangul
+ if (c as u32) >= S_BASE && (c as u32) < (S_BASE + S_COUNT) {
+ decompose_hangul(c, i);
+ return;
+ }
+
+ // First check the canonical decompositions
+ match bsearch_table(c, canonical_table) {
+ Some(canon) => {
+ for x in canon.iter() {
+ d(*x, |b| i(b), k);
+ }
+ return;
+ }
+ None => ()
+ }
+
+ // Bottom out if we're not doing compat.
+ if !k { i(c); return; }
+
+ // Then check the compatibility decompositions
+ match bsearch_table(c, compatibility_table) {
+ Some(compat) => {
+ for x in compat.iter() {
+ d(*x, |b| i(b), k);
+ }
+ return;
+ }
+ None => ()
+ }
+
+ // Finally bottom out.
+ i(c);
+}
+
+// Constants from Unicode 6.3.0 Section 3.12 Conjoining Jamo Behavior
+static S_BASE: u32 = 0xAC00;
+static L_BASE: u32 = 0x1100;
+static V_BASE: u32 = 0x1161;
+static T_BASE: u32 = 0x11A7;
+static L_COUNT: u32 = 19;
+static V_COUNT: u32 = 21;
+static T_COUNT: u32 = 28;
+static N_COUNT: u32 = (V_COUNT * T_COUNT);
+static S_COUNT: u32 = (L_COUNT * N_COUNT);
+
+// Decompose a precomposed Hangul syllable
+fn decompose_hangul(s: char, f: |char|) {
+ use core::mem::transmute;
+
+ let si = s as u32 - S_BASE;
+
+ let li = si / N_COUNT;
+ unsafe {
+ f(transmute(L_BASE + li));
+
+ let vi = (si % N_COUNT) / T_COUNT;
+ f(transmute(V_BASE + vi));
+
+ let ti = si % T_COUNT;
+ if ti > 0 {
+ f(transmute(T_BASE + ti));
+ }
+ }
+}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! # The Unicode Library
+//!
+//! Unicode-intensive functions for `char` and `str` types.
+//!
+//! This crate provides a collection of Unicode-related functionality,
+//! including decompositions, conversions, etc., and provides traits
+//! implementing these functions for the `char` and `str` types.
+//!
+//! The functionality included here is only that which is necessary to
+//! provide for basic string-related manipulations. This crate does not
+//! (yet) aim to provide a full set of Unicode tables.
+
+#![crate_id = "unicode#0.11.0"]
+#![crate_name = "unicode"]
+#![experimental]
+#![license = "MIT/ASL2"]
+#![crate_type = "rlib"]
+#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
+ html_favicon_url = "http://www.rust-lang.org/favicon.ico",
+ html_root_url = "http://doc.rust-lang.org/",
+ html_playground_url = "http://play.rust-lang.org/")]
+#![no_std]
+#![allow(unused_attribute)] // NOTE: remove after stage0
+
+extern crate core;
+
+pub use tables::normalization::canonical_combining_class;
+pub use tables::regex;
+
+pub use u_char::UnicodeChar;
+pub use u_str::UnicodeStrSlice;
+pub use u_str::Words;
+
+mod decompose;
+mod tables;
+mod u_char;
+mod u_str;
+
+// re-export char so that std et al see it correctly
+/// Character manipulation (`char` type, Unicode Scalar Value)
+///
+/// This module provides the `Char` and `UnicodeChar` traits, as well as their
+/// implementation for the primitive `char` type, in order to allow basic character
+/// manipulation.
+///
+/// A `char` actually represents a
+/// *[Unicode Scalar Value](http://www.unicode.org/glossary/#unicode_scalar_value)*,
+/// as it can contain any Unicode code point except high-surrogate and
+/// low-surrogate code points.
+///
+/// As such, only values in the ranges \[0x0,0xD7FF\] and \[0xE000,0x10FFFF\]
+/// (inclusive) are allowed. A `char` can always be safely cast to a `u32`;
+/// however the converse is not always true due to the above range limits
+/// and, as such, should be performed via the `from_u32` function..
+pub mod char {
+ pub use core::char::{MAX, from_u32, is_digit_radix, to_digit};
+ pub use core::char::{from_digit, escape_unicode, escape_default};
+ pub use core::char::{len_utf8_bytes, Char};
+
+ pub use decompose::decompose_canonical;
+ pub use decompose::decompose_compatible;
+
+ pub use u_char::{is_alphabetic, is_XID_start, is_XID_continue};
+ pub use u_char::{is_lowercase, is_uppercase, is_whitespace};
+ pub use u_char::{is_alphanumeric, is_control, is_digit};
+ pub use u_char::{to_uppercase, to_lowercase, width, UnicodeChar};
+}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// NOTE: The following code was generated by "src/etc/unicode.py", do not edit directly
+
+#![allow(missing_doc, non_uppercase_statics, non_snake_case_functions)]
+
+fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
+ use core::cmp::{Equal, Less, Greater};
+ use core::slice::ImmutableVector;
+ use core::option::None;
+ r.bsearch(|&(lo,hi)| {
+ if lo <= c && c <= hi { Equal }
+ else if hi < c { Less }
+ else { Greater }
+ }) != None
+}
+
+pub mod general_category {
+ pub static C_table: &'static [(char, char)] = &[
+ ('\x00', '\x1f'), ('\x7f', '\x9f'), ('\xad', '\xad'), ('\u0600', '\u0605'), ('\u061c',
+ '\u061c'), ('\u06dd', '\u06dd'), ('\u070f', '\u070f'), ('\u180e', '\u180e'), ('\u200b',
+ '\u200f'), ('\u202a', '\u202e'), ('\u2060', '\u2064'), ('\u2066', '\u206f'), ('\ue000',
+ '\ue000'), ('\uf8ff', '\uf8ff'), ('\ufeff', '\ufeff'), ('\ufff9', '\ufffb'), ('\U000110bd',
+ '\U000110bd'), ('\U0001bca0', '\U0001bca3'), ('\U0001d173', '\U0001d17a'), ('\U000e0001',
+ '\U000e0001'), ('\U000e0020', '\U000e007f'), ('\U000f0000', '\U000f0000'), ('\U000ffffd',
+ '\U000ffffd'), ('\U00100000', '\U00100000'), ('\U0010fffd', '\U0010fffd')
+ ];
+
+ pub static Cc_table: &'static [(char, char)] = &[
+ ('\x00', '\x1f'), ('\x7f', '\x9f')
+ ];
+
+ pub fn Cc(c: char) -> bool {
+ super::bsearch_range_table(c, Cc_table)
+ }
+
+ pub static Cf_table: &'static [(char, char)] = &[
+ ('\xad', '\xad'), ('\u0600', '\u0605'), ('\u061c', '\u061c'), ('\u06dd', '\u06dd'),
+ ('\u070f', '\u070f'), ('\u180e', '\u180e'), ('\u200b', '\u200f'), ('\u202a', '\u202e'),
+ ('\u2060', '\u2064'), ('\u2066', '\u206f'), ('\ufeff', '\ufeff'), ('\ufff9', '\ufffb'),
+ ('\U000110bd', '\U000110bd'), ('\U0001bca0', '\U0001bca3'), ('\U0001d173', '\U0001d17a'),
+ ('\U000e0001', '\U000e0001'), ('\U000e0020', '\U000e007f')
+ ];
+
+ pub static Co_table: &'static [(char, char)] = &[
+ ('\ue000', '\ue000'), ('\uf8ff', '\uf8ff'), ('\U000f0000', '\U000f0000'), ('\U000ffffd',
+ '\U000ffffd'), ('\U00100000', '\U00100000'), ('\U0010fffd', '\U0010fffd')
+ ];
+
+ pub static L_table: &'static [(char, char)] = &[
+ ('\x41', '\x5a'), ('\x61', '\x7a'), ('\xaa', '\xaa'), ('\xb5', '\xb5'), ('\xba', '\xba'),
+ ('\xc0', '\xd6'), ('\xd8', '\xf6'), ('\xf8', '\u02c1'), ('\u02c6', '\u02d1'), ('\u02e0',
+ '\u02e4'), ('\u02ec', '\u02ec'), ('\u02ee', '\u02ee'), ('\u0370', '\u0374'), ('\u0376',
+ '\u0377'), ('\u037a', '\u037d'), ('\u037f', '\u037f'), ('\u0386', '\u0386'), ('\u0388',
+ '\u038a'), ('\u038c', '\u038c'), ('\u038e', '\u03a1'), ('\u03a3', '\u03f5'), ('\u03f7',
+ '\u0481'), ('\u048a', '\u052f'), ('\u0531', '\u0556'), ('\u0559', '\u0559'), ('\u0561',
+ '\u0587'), ('\u05d0', '\u05ea'), ('\u05f0', '\u05f2'), ('\u0620', '\u064a'), ('\u066e',
+ '\u066f'), ('\u0671', '\u06d3'), ('\u06d5', '\u06d5'), ('\u06e5', '\u06e6'), ('\u06ee',
+ '\u06ef'), ('\u06fa', '\u06fc'), ('\u06ff', '\u06ff'), ('\u0710', '\u0710'), ('\u0712',
+ '\u072f'), ('\u074d', '\u07a5'), ('\u07b1', '\u07b1'), ('\u07ca', '\u07ea'), ('\u07f4',
+ '\u07f5'), ('\u07fa', '\u07fa'), ('\u0800', '\u0815'), ('\u081a', '\u081a'), ('\u0824',
+ '\u0824'), ('\u0828', '\u0828'), ('\u0840', '\u0858'), ('\u08a0', '\u08b2'), ('\u0904',
+ '\u0939'), ('\u093d', '\u093d'), ('\u0950', '\u0950'), ('\u0958', '\u0961'), ('\u0971',
+ '\u0980'), ('\u0985', '\u098c'), ('\u098f', '\u0990'), ('\u0993', '\u09a8'), ('\u09aa',
+ '\u09b0'), ('\u09b2', '\u09b2'), ('\u09b6', '\u09b9'), ('\u09bd', '\u09bd'), ('\u09ce',
+ '\u09ce'), ('\u09dc', '\u09dd'), ('\u09df', '\u09e1'), ('\u09f0', '\u09f1'), ('\u0a05',
+ '\u0a0a'), ('\u0a0f', '\u0a10'), ('\u0a13', '\u0a28'), ('\u0a2a', '\u0a30'), ('\u0a32',
+ '\u0a33'), ('\u0a35', '\u0a36'), ('\u0a38', '\u0a39'), ('\u0a59', '\u0a5c'), ('\u0a5e',
+ '\u0a5e'), ('\u0a72', '\u0a74'), ('\u0a85', '\u0a8d'), ('\u0a8f', '\u0a91'), ('\u0a93',
+ '\u0aa8'), ('\u0aaa', '\u0ab0'), ('\u0ab2', '\u0ab3'), ('\u0ab5', '\u0ab9'), ('\u0abd',
+ '\u0abd'), ('\u0ad0', '\u0ad0'), ('\u0ae0', '\u0ae1'), ('\u0b05', '\u0b0c'), ('\u0b0f',
+ '\u0b10'), ('\u0b13', '\u0b28'), ('\u0b2a', '\u0b30'), ('\u0b32', '\u0b33'), ('\u0b35',
+ '\u0b39'), ('\u0b3d', '\u0b3d'), ('\u0b5c', '\u0b5d'), ('\u0b5f', '\u0b61'), ('\u0b71',
+ '\u0b71'), ('\u0b83', '\u0b83'), ('\u0b85', '\u0b8a'), ('\u0b8e', '\u0b90'), ('\u0b92',
+ '\u0b95'), ('\u0b99', '\u0b9a'), ('\u0b9c', '\u0b9c'), ('\u0b9e', '\u0b9f'), ('\u0ba3',
+ '\u0ba4'), ('\u0ba8', '\u0baa'), ('\u0bae', '\u0bb9'), ('\u0bd0', '\u0bd0'), ('\u0c05',
+ '\u0c0c'), ('\u0c0e', '\u0c10'), ('\u0c12', '\u0c28'), ('\u0c2a', '\u0c39'), ('\u0c3d',
+ '\u0c3d'), ('\u0c58', '\u0c59'), ('\u0c60', '\u0c61'), ('\u0c85', '\u0c8c'), ('\u0c8e',
+ '\u0c90'), ('\u0c92', '\u0ca8'), ('\u0caa', '\u0cb3'), ('\u0cb5', '\u0cb9'), ('\u0cbd',
+ '\u0cbd'), ('\u0cde', '\u0cde'), ('\u0ce0', '\u0ce1'), ('\u0cf1', '\u0cf2'), ('\u0d05',
+ '\u0d0c'), ('\u0d0e', '\u0d10'), ('\u0d12', '\u0d3a'), ('\u0d3d', '\u0d3d'), ('\u0d4e',
+ '\u0d4e'), ('\u0d60', '\u0d61'), ('\u0d7a', '\u0d7f'), ('\u0d85', '\u0d96'), ('\u0d9a',
+ '\u0db1'), ('\u0db3', '\u0dbb'), ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'), ('\u0e01',
+ '\u0e30'), ('\u0e32', '\u0e33'), ('\u0e40', '\u0e46'), ('\u0e81', '\u0e82'), ('\u0e84',
+ '\u0e84'), ('\u0e87', '\u0e88'), ('\u0e8a', '\u0e8a'), ('\u0e8d', '\u0e8d'), ('\u0e94',
+ '\u0e97'), ('\u0e99', '\u0e9f'), ('\u0ea1', '\u0ea3'), ('\u0ea5', '\u0ea5'), ('\u0ea7',
+ '\u0ea7'), ('\u0eaa', '\u0eab'), ('\u0ead', '\u0eb0'), ('\u0eb2', '\u0eb3'), ('\u0ebd',
+ '\u0ebd'), ('\u0ec0', '\u0ec4'), ('\u0ec6', '\u0ec6'), ('\u0edc', '\u0edf'), ('\u0f00',
+ '\u0f00'), ('\u0f40', '\u0f47'), ('\u0f49', '\u0f6c'), ('\u0f88', '\u0f8c'), ('\u1000',
+ '\u102a'), ('\u103f', '\u103f'), ('\u1050', '\u1055'), ('\u105a', '\u105d'), ('\u1061',
+ '\u1061'), ('\u1065', '\u1066'), ('\u106e', '\u1070'), ('\u1075', '\u1081'), ('\u108e',
+ '\u108e'), ('\u10a0', '\u10c5'), ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'), ('\u10d0',
+ '\u10fa'), ('\u10fc', '\u1248'), ('\u124a', '\u124d'), ('\u1250', '\u1256'), ('\u1258',
+ '\u1258'), ('\u125a', '\u125d'), ('\u1260', '\u1288'), ('\u128a', '\u128d'), ('\u1290',
+ '\u12b0'), ('\u12b2', '\u12b5'), ('\u12b8', '\u12be'), ('\u12c0', '\u12c0'), ('\u12c2',
+ '\u12c5'), ('\u12c8', '\u12d6'), ('\u12d8', '\u1310'), ('\u1312', '\u1315'), ('\u1318',
+ '\u135a'), ('\u1380', '\u138f'), ('\u13a0', '\u13f4'), ('\u1401', '\u166c'), ('\u166f',
+ '\u167f'), ('\u1681', '\u169a'), ('\u16a0', '\u16ea'), ('\u16f1', '\u16f8'), ('\u1700',
+ '\u170c'), ('\u170e', '\u1711'), ('\u1720', '\u1731'), ('\u1740', '\u1751'), ('\u1760',
+ '\u176c'), ('\u176e', '\u1770'), ('\u1780', '\u17b3'), ('\u17d7', '\u17d7'), ('\u17dc',
+ '\u17dc'), ('\u1820', '\u1877'), ('\u1880', '\u18a8'), ('\u18aa', '\u18aa'), ('\u18b0',
+ '\u18f5'), ('\u1900', '\u191e'), ('\u1950', '\u196d'), ('\u1970', '\u1974'), ('\u1980',
+ '\u19ab'), ('\u19c1', '\u19c7'), ('\u1a00', '\u1a16'), ('\u1a20', '\u1a54'), ('\u1aa7',
+ '\u1aa7'), ('\u1b05', '\u1b33'), ('\u1b45', '\u1b4b'), ('\u1b83', '\u1ba0'), ('\u1bae',
+ '\u1baf'), ('\u1bba', '\u1be5'), ('\u1c00', '\u1c23'), ('\u1c4d', '\u1c4f'), ('\u1c5a',
+ '\u1c7d'), ('\u1ce9', '\u1cec'), ('\u1cee', '\u1cf1'), ('\u1cf5', '\u1cf6'), ('\u1d00',
+ '\u1dbf'), ('\u1e00', '\u1f15'), ('\u1f18', '\u1f1d'), ('\u1f20', '\u1f45'), ('\u1f48',
+ '\u1f4d'), ('\u1f50', '\u1f57'), ('\u1f59', '\u1f59'), ('\u1f5b', '\u1f5b'), ('\u1f5d',
+ '\u1f5d'), ('\u1f5f', '\u1f7d'), ('\u1f80', '\u1fb4'), ('\u1fb6', '\u1fbc'), ('\u1fbe',
+ '\u1fbe'), ('\u1fc2', '\u1fc4'), ('\u1fc6', '\u1fcc'), ('\u1fd0', '\u1fd3'), ('\u1fd6',
+ '\u1fdb'), ('\u1fe0', '\u1fec'), ('\u1ff2', '\u1ff4'), ('\u1ff6', '\u1ffc'), ('\u2071',
+ '\u2071'), ('\u207f', '\u207f'), ('\u2090', '\u209c'), ('\u2102', '\u2102'), ('\u2107',
+ '\u2107'), ('\u210a', '\u2113'), ('\u2115', '\u2115'), ('\u2119', '\u211d'), ('\u2124',
+ '\u2124'), ('\u2126', '\u2126'), ('\u2128', '\u2128'), ('\u212a', '\u212d'), ('\u212f',
+ '\u2139'), ('\u213c', '\u213f'), ('\u2145', '\u2149'), ('\u214e', '\u214e'), ('\u2183',
+ '\u2184'), ('\u2c00', '\u2c2e'), ('\u2c30', '\u2c5e'), ('\u2c60', '\u2ce4'), ('\u2ceb',
+ '\u2cee'), ('\u2cf2', '\u2cf3'), ('\u2d00', '\u2d25'), ('\u2d27', '\u2d27'), ('\u2d2d',
+ '\u2d2d'), ('\u2d30', '\u2d67'), ('\u2d6f', '\u2d6f'), ('\u2d80', '\u2d96'), ('\u2da0',
+ '\u2da6'), ('\u2da8', '\u2dae'), ('\u2db0', '\u2db6'), ('\u2db8', '\u2dbe'), ('\u2dc0',
+ '\u2dc6'), ('\u2dc8', '\u2dce'), ('\u2dd0', '\u2dd6'), ('\u2dd8', '\u2dde'), ('\u2e2f',
+ '\u2e2f'), ('\u3005', '\u3006'), ('\u3031', '\u3035'), ('\u303b', '\u303c'), ('\u3041',
+ '\u3096'), ('\u309d', '\u309f'), ('\u30a1', '\u30fa'), ('\u30fc', '\u30ff'), ('\u3105',
+ '\u312d'), ('\u3131', '\u318e'), ('\u31a0', '\u31ba'), ('\u31f0', '\u31ff'), ('\u3400',
+ '\u3400'), ('\u4db5', '\u4db5'), ('\u4e00', '\u4e00'), ('\u9fcc', '\u9fcc'), ('\ua000',
+ '\ua48c'), ('\ua4d0', '\ua4fd'), ('\ua500', '\ua60c'), ('\ua610', '\ua61f'), ('\ua62a',
+ '\ua62b'), ('\ua640', '\ua66e'), ('\ua67f', '\ua69d'), ('\ua6a0', '\ua6e5'), ('\ua717',
+ '\ua71f'), ('\ua722', '\ua788'), ('\ua78b', '\ua78e'), ('\ua790', '\ua7ad'), ('\ua7b0',
+ '\ua7b1'), ('\ua7f7', '\ua801'), ('\ua803', '\ua805'), ('\ua807', '\ua80a'), ('\ua80c',
+ '\ua822'), ('\ua840', '\ua873'), ('\ua882', '\ua8b3'), ('\ua8f2', '\ua8f7'), ('\ua8fb',
+ '\ua8fb'), ('\ua90a', '\ua925'), ('\ua930', '\ua946'), ('\ua960', '\ua97c'), ('\ua984',
+ '\ua9b2'), ('\ua9cf', '\ua9cf'), ('\ua9e0', '\ua9e4'), ('\ua9e6', '\ua9ef'), ('\ua9fa',
+ '\ua9fe'), ('\uaa00', '\uaa28'), ('\uaa40', '\uaa42'), ('\uaa44', '\uaa4b'), ('\uaa60',
+ '\uaa76'), ('\uaa7a', '\uaa7a'), ('\uaa7e', '\uaaaf'), ('\uaab1', '\uaab1'), ('\uaab5',
+ '\uaab6'), ('\uaab9', '\uaabd'), ('\uaac0', '\uaac0'), ('\uaac2', '\uaac2'), ('\uaadb',
+ '\uaadd'), ('\uaae0', '\uaaea'), ('\uaaf2', '\uaaf4'), ('\uab01', '\uab06'), ('\uab09',
+ '\uab0e'), ('\uab11', '\uab16'), ('\uab20', '\uab26'), ('\uab28', '\uab2e'), ('\uab30',
+ '\uab5a'), ('\uab5c', '\uab5f'), ('\uab64', '\uab65'), ('\uabc0', '\uabe2'), ('\uac00',
+ '\uac00'), ('\ud7a3', '\ud7a3'), ('\ud7b0', '\ud7c6'), ('\ud7cb', '\ud7fb'), ('\uf900',
+ '\ufa6d'), ('\ufa70', '\ufad9'), ('\ufb00', '\ufb06'), ('\ufb13', '\ufb17'), ('\ufb1d',
+ '\ufb1d'), ('\ufb1f', '\ufb28'), ('\ufb2a', '\ufb36'), ('\ufb38', '\ufb3c'), ('\ufb3e',
+ '\ufb3e'), ('\ufb40', '\ufb41'), ('\ufb43', '\ufb44'), ('\ufb46', '\ufbb1'), ('\ufbd3',
+ '\ufd3d'), ('\ufd50', '\ufd8f'), ('\ufd92', '\ufdc7'), ('\ufdf0', '\ufdfb'), ('\ufe70',
+ '\ufe74'), ('\ufe76', '\ufefc'), ('\uff21', '\uff3a'), ('\uff41', '\uff5a'), ('\uff66',
+ '\uffbe'), ('\uffc2', '\uffc7'), ('\uffca', '\uffcf'), ('\uffd2', '\uffd7'), ('\uffda',
+ '\uffdc'), ('\U00010000', '\U0001000b'), ('\U0001000d', '\U00010026'), ('\U00010028',
+ '\U0001003a'), ('\U0001003c', '\U0001003d'), ('\U0001003f', '\U0001004d'), ('\U00010050',
+ '\U0001005d'), ('\U00010080', '\U000100fa'), ('\U00010280', '\U0001029c'), ('\U000102a0',
+ '\U000102d0'), ('\U00010300', '\U0001031f'), ('\U00010330', '\U00010340'), ('\U00010342',
+ '\U00010349'), ('\U00010350', '\U00010375'), ('\U00010380', '\U0001039d'), ('\U000103a0',
+ '\U000103c3'), ('\U000103c8', '\U000103cf'), ('\U00010400', '\U0001049d'), ('\U00010500',
+ '\U00010527'), ('\U00010530', '\U00010563'), ('\U00010600', '\U00010736'), ('\U00010740',
+ '\U00010755'), ('\U00010760', '\U00010767'), ('\U00010800', '\U00010805'), ('\U00010808',
+ '\U00010808'), ('\U0001080a', '\U00010835'), ('\U00010837', '\U00010838'), ('\U0001083c',
+ '\U0001083c'), ('\U0001083f', '\U00010855'), ('\U00010860', '\U00010876'), ('\U00010880',
+ '\U0001089e'), ('\U00010900', '\U00010915'), ('\U00010920', '\U00010939'), ('\U00010980',
+ '\U000109b7'), ('\U000109be', '\U000109bf'), ('\U00010a00', '\U00010a00'), ('\U00010a10',
+ '\U00010a13'), ('\U00010a15', '\U00010a17'), ('\U00010a19', '\U00010a33'), ('\U00010a60',
+ '\U00010a7c'), ('\U00010a80', '\U00010a9c'), ('\U00010ac0', '\U00010ac7'), ('\U00010ac9',
+ '\U00010ae4'), ('\U00010b00', '\U00010b35'), ('\U00010b40', '\U00010b55'), ('\U00010b60',
+ '\U00010b72'), ('\U00010b80', '\U00010b91'), ('\U00010c00', '\U00010c48'), ('\U00011003',
+ '\U00011037'), ('\U00011083', '\U000110af'), ('\U000110d0', '\U000110e8'), ('\U00011103',
+ '\U00011126'), ('\U00011150', '\U00011172'), ('\U00011176', '\U00011176'), ('\U00011183',
+ '\U000111b2'), ('\U000111c1', '\U000111c4'), ('\U000111da', '\U000111da'), ('\U00011200',
+ '\U00011211'), ('\U00011213', '\U0001122b'), ('\U000112b0', '\U000112de'), ('\U00011305',
+ '\U0001130c'), ('\U0001130f', '\U00011310'), ('\U00011313', '\U00011328'), ('\U0001132a',
+ '\U00011330'), ('\U00011332', '\U00011333'), ('\U00011335', '\U00011339'), ('\U0001133d',
+ '\U0001133d'), ('\U0001135d', '\U00011361'), ('\U00011480', '\U000114af'), ('\U000114c4',
+ '\U000114c5'), ('\U000114c7', '\U000114c7'), ('\U00011580', '\U000115ae'), ('\U00011600',
+ '\U0001162f'), ('\U00011644', '\U00011644'), ('\U00011680', '\U000116aa'), ('\U000118a0',
+ '\U000118df'), ('\U000118ff', '\U000118ff'), ('\U00011ac0', '\U00011af8'), ('\U00012000',
+ '\U00012398'), ('\U00013000', '\U0001342e'), ('\U00016800', '\U00016a38'), ('\U00016a40',
+ '\U00016a5e'), ('\U00016ad0', '\U00016aed'), ('\U00016b00', '\U00016b2f'), ('\U00016b40',
+ '\U00016b43'), ('\U00016b63', '\U00016b77'), ('\U00016b7d', '\U00016b8f'), ('\U00016f00',
+ '\U00016f44'), ('\U00016f50', '\U00016f50'), ('\U00016f93', '\U00016f9f'), ('\U0001b000',
+ '\U0001b001'), ('\U0001bc00', '\U0001bc6a'), ('\U0001bc70', '\U0001bc7c'), ('\U0001bc80',
+ '\U0001bc88'), ('\U0001bc90', '\U0001bc99'), ('\U0001d400', '\U0001d454'), ('\U0001d456',
+ '\U0001d49c'), ('\U0001d49e', '\U0001d49f'), ('\U0001d4a2', '\U0001d4a2'), ('\U0001d4a5',
+ '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'), ('\U0001d4ae', '\U0001d4b9'), ('\U0001d4bb',
+ '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5', '\U0001d505'), ('\U0001d507',
+ '\U0001d50a'), ('\U0001d50d', '\U0001d514'), ('\U0001d516', '\U0001d51c'), ('\U0001d51e',
+ '\U0001d539'), ('\U0001d53b', '\U0001d53e'), ('\U0001d540', '\U0001d544'), ('\U0001d546',
+ '\U0001d546'), ('\U0001d54a', '\U0001d550'), ('\U0001d552', '\U0001d6a5'), ('\U0001d6a8',
+ '\U0001d6c0'), ('\U0001d6c2', '\U0001d6da'), ('\U0001d6dc', '\U0001d6fa'), ('\U0001d6fc',
+ '\U0001d714'), ('\U0001d716', '\U0001d734'), ('\U0001d736', '\U0001d74e'), ('\U0001d750',
+ '\U0001d76e'), ('\U0001d770', '\U0001d788'), ('\U0001d78a', '\U0001d7a8'), ('\U0001d7aa',
+ '\U0001d7c2'), ('\U0001d7c4', '\U0001d7cb'), ('\U0001e800', '\U0001e8c4'), ('\U0001ee00',
+ '\U0001ee03'), ('\U0001ee05', '\U0001ee1f'), ('\U0001ee21', '\U0001ee22'), ('\U0001ee24',
+ '\U0001ee24'), ('\U0001ee27', '\U0001ee27'), ('\U0001ee29', '\U0001ee32'), ('\U0001ee34',
+ '\U0001ee37'), ('\U0001ee39', '\U0001ee39'), ('\U0001ee3b', '\U0001ee3b'), ('\U0001ee42',
+ '\U0001ee42'), ('\U0001ee47', '\U0001ee47'), ('\U0001ee49', '\U0001ee49'), ('\U0001ee4b',
+ '\U0001ee4b'), ('\U0001ee4d', '\U0001ee4f'), ('\U0001ee51', '\U0001ee52'), ('\U0001ee54',
+ '\U0001ee54'), ('\U0001ee57', '\U0001ee57'), ('\U0001ee59', '\U0001ee59'), ('\U0001ee5b',
+ '\U0001ee5b'), ('\U0001ee5d', '\U0001ee5d'), ('\U0001ee5f', '\U0001ee5f'), ('\U0001ee61',
+ '\U0001ee62'), ('\U0001ee64', '\U0001ee64'), ('\U0001ee67', '\U0001ee6a'), ('\U0001ee6c',
+ '\U0001ee72'), ('\U0001ee74', '\U0001ee77'), ('\U0001ee79', '\U0001ee7c'), ('\U0001ee7e',
+ '\U0001ee7e'), ('\U0001ee80', '\U0001ee89'), ('\U0001ee8b', '\U0001ee9b'), ('\U0001eea1',
+ '\U0001eea3'), ('\U0001eea5', '\U0001eea9'), ('\U0001eeab', '\U0001eebb'), ('\U00020000',
+ '\U00020000'), ('\U0002a6d6', '\U0002a6d6'), ('\U0002a700', '\U0002a700'), ('\U0002b734',
+ '\U0002b734'), ('\U0002b740', '\U0002b740'), ('\U0002b81d', '\U0002b81d'), ('\U0002f800',
+ '\U0002fa1d')
+ ];
+
+ pub static LC_table: &'static [(char, char)] = &[
+ ('\x41', '\x5a'), ('\x61', '\x7a'), ('\xb5', '\xb5'), ('\xc0', '\xd6'), ('\xd8', '\xf6'),
+ ('\xf8', '\u01ba'), ('\u01bc', '\u01bf'), ('\u01c4', '\u0293'), ('\u0295', '\u02af'),
+ ('\u0370', '\u0373'), ('\u0376', '\u0377'), ('\u037b', '\u037d'), ('\u037f', '\u037f'),
+ ('\u0386', '\u0386'), ('\u0388', '\u038a'), ('\u038c', '\u038c'), ('\u038e', '\u03a1'),
+ ('\u03a3', '\u03f5'), ('\u03f7', '\u0481'), ('\u048a', '\u052f'), ('\u0531', '\u0556'),
+ ('\u0561', '\u0587'), ('\u10a0', '\u10c5'), ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'),
+ ('\u1d00', '\u1d2b'), ('\u1d6b', '\u1d77'), ('\u1d79', '\u1d9a'), ('\u1e00', '\u1f15'),
+ ('\u1f18', '\u1f1d'), ('\u1f20', '\u1f45'), ('\u1f48', '\u1f4d'), ('\u1f50', '\u1f57'),
+ ('\u1f59', '\u1f59'), ('\u1f5b', '\u1f5b'), ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f7d'),
+ ('\u1f80', '\u1fb4'), ('\u1fb6', '\u1fbc'), ('\u1fbe', '\u1fbe'), ('\u1fc2', '\u1fc4'),
+ ('\u1fc6', '\u1fcc'), ('\u1fd0', '\u1fd3'), ('\u1fd6', '\u1fdb'), ('\u1fe0', '\u1fec'),
+ ('\u1ff2', '\u1ff4'), ('\u1ff6', '\u1ffc'), ('\u2102', '\u2102'), ('\u2107', '\u2107'),
+ ('\u210a', '\u2113'), ('\u2115', '\u2115'), ('\u2119', '\u211d'), ('\u2124', '\u2124'),
+ ('\u2126', '\u2126'), ('\u2128', '\u2128'), ('\u212a', '\u212d'), ('\u212f', '\u2134'),
+ ('\u2139', '\u2139'), ('\u213c', '\u213f'), ('\u2145', '\u2149'), ('\u214e', '\u214e'),
+ ('\u2183', '\u2184'), ('\u2c00', '\u2c2e'), ('\u2c30', '\u2c5e'), ('\u2c60', '\u2c7b'),
+ ('\u2c7e', '\u2ce4'), ('\u2ceb', '\u2cee'), ('\u2cf2', '\u2cf3'), ('\u2d00', '\u2d25'),
+ ('\u2d27', '\u2d27'), ('\u2d2d', '\u2d2d'), ('\ua640', '\ua66d'), ('\ua680', '\ua69b'),
+ ('\ua722', '\ua76f'), ('\ua771', '\ua787'), ('\ua78b', '\ua78e'), ('\ua790', '\ua7ad'),
+ ('\ua7b0', '\ua7b1'), ('\ua7fa', '\ua7fa'), ('\uab30', '\uab5a'), ('\uab64', '\uab65'),
+ ('\ufb00', '\ufb06'), ('\ufb13', '\ufb17'), ('\uff21', '\uff3a'), ('\uff41', '\uff5a'),
+ ('\U00010400', '\U0001044f'), ('\U000118a0', '\U000118df'), ('\U0001d400', '\U0001d454'),
+ ('\U0001d456', '\U0001d49c'), ('\U0001d49e', '\U0001d49f'), ('\U0001d4a2', '\U0001d4a2'),
+ ('\U0001d4a5', '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'), ('\U0001d4ae', '\U0001d4b9'),
+ ('\U0001d4bb', '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5', '\U0001d505'),
+ ('\U0001d507', '\U0001d50a'), ('\U0001d50d', '\U0001d514'), ('\U0001d516', '\U0001d51c'),
+ ('\U0001d51e', '\U0001d539'), ('\U0001d53b', '\U0001d53e'), ('\U0001d540', '\U0001d544'),
+ ('\U0001d546', '\U0001d546'), ('\U0001d54a', '\U0001d550'), ('\U0001d552', '\U0001d6a5'),
+ ('\U0001d6a8', '\U0001d6c0'), ('\U0001d6c2', '\U0001d6da'), ('\U0001d6dc', '\U0001d6fa'),
+ ('\U0001d6fc', '\U0001d714'), ('\U0001d716', '\U0001d734'), ('\U0001d736', '\U0001d74e'),
+ ('\U0001d750', '\U0001d76e'), ('\U0001d770', '\U0001d788'), ('\U0001d78a', '\U0001d7a8'),
+ ('\U0001d7aa', '\U0001d7c2'), ('\U0001d7c4', '\U0001d7cb')
+ ];
+
+ pub static Ll_table: &'static [(char, char)] = &[
+ ('\x61', '\x7a'), ('\xb5', '\xb5'), ('\xdf', '\xf6'), ('\xf8', '\xff'), ('\u0101',
+ '\u0101'), ('\u0103', '\u0103'), ('\u0105', '\u0105'), ('\u0107', '\u0107'), ('\u0109',
+ '\u0109'), ('\u010b', '\u010b'), ('\u010d', '\u010d'), ('\u010f', '\u010f'), ('\u0111',
+ '\u0111'), ('\u0113', '\u0113'), ('\u0115', '\u0115'), ('\u0117', '\u0117'), ('\u0119',
+ '\u0119'), ('\u011b', '\u011b'), ('\u011d', '\u011d'), ('\u011f', '\u011f'), ('\u0121',
+ '\u0121'), ('\u0123', '\u0123'), ('\u0125', '\u0125'), ('\u0127', '\u0127'), ('\u0129',
+ '\u0129'), ('\u012b', '\u012b'), ('\u012d', '\u012d'), ('\u012f', '\u012f'), ('\u0131',
+ '\u0131'), ('\u0133', '\u0133'), ('\u0135', '\u0135'), ('\u0137', '\u0138'), ('\u013a',
+ '\u013a'), ('\u013c', '\u013c'), ('\u013e', '\u013e'), ('\u0140', '\u0140'), ('\u0142',
+ '\u0142'), ('\u0144', '\u0144'), ('\u0146', '\u0146'), ('\u0148', '\u0149'), ('\u014b',
+ '\u014b'), ('\u014d', '\u014d'), ('\u014f', '\u014f'), ('\u0151', '\u0151'), ('\u0153',
+ '\u0153'), ('\u0155', '\u0155'), ('\u0157', '\u0157'), ('\u0159', '\u0159'), ('\u015b',
+ '\u015b'), ('\u015d', '\u015d'), ('\u015f', '\u015f'), ('\u0161', '\u0161'), ('\u0163',
+ '\u0163'), ('\u0165', '\u0165'), ('\u0167', '\u0167'), ('\u0169', '\u0169'), ('\u016b',
+ '\u016b'), ('\u016d', '\u016d'), ('\u016f', '\u016f'), ('\u0171', '\u0171'), ('\u0173',
+ '\u0173'), ('\u0175', '\u0175'), ('\u0177', '\u0177'), ('\u017a', '\u017a'), ('\u017c',
+ '\u017c'), ('\u017e', '\u0180'), ('\u0183', '\u0183'), ('\u0185', '\u0185'), ('\u0188',
+ '\u0188'), ('\u018c', '\u018d'), ('\u0192', '\u0192'), ('\u0195', '\u0195'), ('\u0199',
+ '\u019b'), ('\u019e', '\u019e'), ('\u01a1', '\u01a1'), ('\u01a3', '\u01a3'), ('\u01a5',
+ '\u01a5'), ('\u01a8', '\u01a8'), ('\u01aa', '\u01ab'), ('\u01ad', '\u01ad'), ('\u01b0',
+ '\u01b0'), ('\u01b4', '\u01b4'), ('\u01b6', '\u01b6'), ('\u01b9', '\u01ba'), ('\u01bd',
+ '\u01bf'), ('\u01c6', '\u01c6'), ('\u01c9', '\u01c9'), ('\u01cc', '\u01cc'), ('\u01ce',
+ '\u01ce'), ('\u01d0', '\u01d0'), ('\u01d2', '\u01d2'), ('\u01d4', '\u01d4'), ('\u01d6',
+ '\u01d6'), ('\u01d8', '\u01d8'), ('\u01da', '\u01da'), ('\u01dc', '\u01dd'), ('\u01df',
+ '\u01df'), ('\u01e1', '\u01e1'), ('\u01e3', '\u01e3'), ('\u01e5', '\u01e5'), ('\u01e7',
+ '\u01e7'), ('\u01e9', '\u01e9'), ('\u01eb', '\u01eb'), ('\u01ed', '\u01ed'), ('\u01ef',
+ '\u01f0'), ('\u01f3', '\u01f3'), ('\u01f5', '\u01f5'), ('\u01f9', '\u01f9'), ('\u01fb',
+ '\u01fb'), ('\u01fd', '\u01fd'), ('\u01ff', '\u01ff'), ('\u0201', '\u0201'), ('\u0203',
+ '\u0203'), ('\u0205', '\u0205'), ('\u0207', '\u0207'), ('\u0209', '\u0209'), ('\u020b',
+ '\u020b'), ('\u020d', '\u020d'), ('\u020f', '\u020f'), ('\u0211', '\u0211'), ('\u0213',
+ '\u0213'), ('\u0215', '\u0215'), ('\u0217', '\u0217'), ('\u0219', '\u0219'), ('\u021b',
+ '\u021b'), ('\u021d', '\u021d'), ('\u021f', '\u021f'), ('\u0221', '\u0221'), ('\u0223',
+ '\u0223'), ('\u0225', '\u0225'), ('\u0227', '\u0227'), ('\u0229', '\u0229'), ('\u022b',
+ '\u022b'), ('\u022d', '\u022d'), ('\u022f', '\u022f'), ('\u0231', '\u0231'), ('\u0233',
+ '\u0239'), ('\u023c', '\u023c'), ('\u023f', '\u0240'), ('\u0242', '\u0242'), ('\u0247',
+ '\u0247'), ('\u0249', '\u0249'), ('\u024b', '\u024b'), ('\u024d', '\u024d'), ('\u024f',
+ '\u0293'), ('\u0295', '\u02af'), ('\u0371', '\u0371'), ('\u0373', '\u0373'), ('\u0377',
+ '\u0377'), ('\u037b', '\u037d'), ('\u0390', '\u0390'), ('\u03ac', '\u03ce'), ('\u03d0',
+ '\u03d1'), ('\u03d5', '\u03d7'), ('\u03d9', '\u03d9'), ('\u03db', '\u03db'), ('\u03dd',
+ '\u03dd'), ('\u03df', '\u03df'), ('\u03e1', '\u03e1'), ('\u03e3', '\u03e3'), ('\u03e5',
+ '\u03e5'), ('\u03e7', '\u03e7'), ('\u03e9', '\u03e9'), ('\u03eb', '\u03eb'), ('\u03ed',
+ '\u03ed'), ('\u03ef', '\u03f3'), ('\u03f5', '\u03f5'), ('\u03f8', '\u03f8'), ('\u03fb',
+ '\u03fc'), ('\u0430', '\u045f'), ('\u0461', '\u0461'), ('\u0463', '\u0463'), ('\u0465',
+ '\u0465'), ('\u0467', '\u0467'), ('\u0469', '\u0469'), ('\u046b', '\u046b'), ('\u046d',
+ '\u046d'), ('\u046f', '\u046f'), ('\u0471', '\u0471'), ('\u0473', '\u0473'), ('\u0475',
+ '\u0475'), ('\u0477', '\u0477'), ('\u0479', '\u0479'), ('\u047b', '\u047b'), ('\u047d',
+ '\u047d'), ('\u047f', '\u047f'), ('\u0481', '\u0481'), ('\u048b', '\u048b'), ('\u048d',
+ '\u048d'), ('\u048f', '\u048f'), ('\u0491', '\u0491'), ('\u0493', '\u0493'), ('\u0495',
+ '\u0495'), ('\u0497', '\u0497'), ('\u0499', '\u0499'), ('\u049b', '\u049b'), ('\u049d',
+ '\u049d'), ('\u049f', '\u049f'), ('\u04a1', '\u04a1'), ('\u04a3', '\u04a3'), ('\u04a5',
+ '\u04a5'), ('\u04a7', '\u04a7'), ('\u04a9', '\u04a9'), ('\u04ab', '\u04ab'), ('\u04ad',
+ '\u04ad'), ('\u04af', '\u04af'), ('\u04b1', '\u04b1'), ('\u04b3', '\u04b3'), ('\u04b5',
+ '\u04b5'), ('\u04b7', '\u04b7'), ('\u04b9', '\u04b9'), ('\u04bb', '\u04bb'), ('\u04bd',
+ '\u04bd'), ('\u04bf', '\u04bf'), ('\u04c2', '\u04c2'), ('\u04c4', '\u04c4'), ('\u04c6',
+ '\u04c6'), ('\u04c8', '\u04c8'), ('\u04ca', '\u04ca'), ('\u04cc', '\u04cc'), ('\u04ce',
+ '\u04cf'), ('\u04d1', '\u04d1'), ('\u04d3', '\u04d3'), ('\u04d5', '\u04d5'), ('\u04d7',
+ '\u04d7'), ('\u04d9', '\u04d9'), ('\u04db', '\u04db'), ('\u04dd', '\u04dd'), ('\u04df',
+ '\u04df'), ('\u04e1', '\u04e1'), ('\u04e3', '\u04e3'), ('\u04e5', '\u04e5'), ('\u04e7',
+ '\u04e7'), ('\u04e9', '\u04e9'), ('\u04eb', '\u04eb'), ('\u04ed', '\u04ed'), ('\u04ef',
+ '\u04ef'), ('\u04f1', '\u04f1'), ('\u04f3', '\u04f3'), ('\u04f5', '\u04f5'), ('\u04f7',
+ '\u04f7'), ('\u04f9', '\u04f9'), ('\u04fb', '\u04fb'), ('\u04fd', '\u04fd'), ('\u04ff',
+ '\u04ff'), ('\u0501', '\u0501'), ('\u0503', '\u0503'), ('\u0505', '\u0505'), ('\u0507',
+ '\u0507'), ('\u0509', '\u0509'), ('\u050b', '\u050b'), ('\u050d', '\u050d'), ('\u050f',
+ '\u050f'), ('\u0511', '\u0511'), ('\u0513', '\u0513'), ('\u0515', '\u0515'), ('\u0517',
+ '\u0517'), ('\u0519', '\u0519'), ('\u051b', '\u051b'), ('\u051d', '\u051d'), ('\u051f',
+ '\u051f'), ('\u0521', '\u0521'), ('\u0523', '\u0523'), ('\u0525', '\u0525'), ('\u0527',
+ '\u0527'), ('\u0529', '\u0529'), ('\u052b', '\u052b'), ('\u052d', '\u052d'), ('\u052f',
+ '\u052f'), ('\u0561', '\u0587'), ('\u1d00', '\u1d2b'), ('\u1d6b', '\u1d77'), ('\u1d79',
+ '\u1d9a'), ('\u1e01', '\u1e01'), ('\u1e03', '\u1e03'), ('\u1e05', '\u1e05'), ('\u1e07',
+ '\u1e07'), ('\u1e09', '\u1e09'), ('\u1e0b', '\u1e0b'), ('\u1e0d', '\u1e0d'), ('\u1e0f',
+ '\u1e0f'), ('\u1e11', '\u1e11'), ('\u1e13', '\u1e13'), ('\u1e15', '\u1e15'), ('\u1e17',
+ '\u1e17'), ('\u1e19', '\u1e19'), ('\u1e1b', '\u1e1b'), ('\u1e1d', '\u1e1d'), ('\u1e1f',
+ '\u1e1f'), ('\u1e21', '\u1e21'), ('\u1e23', '\u1e23'), ('\u1e25', '\u1e25'), ('\u1e27',
+ '\u1e27'), ('\u1e29', '\u1e29'), ('\u1e2b', '\u1e2b'), ('\u1e2d', '\u1e2d'), ('\u1e2f',
+ '\u1e2f'), ('\u1e31', '\u1e31'), ('\u1e33', '\u1e33'), ('\u1e35', '\u1e35'), ('\u1e37',
+ '\u1e37'), ('\u1e39', '\u1e39'), ('\u1e3b', '\u1e3b'), ('\u1e3d', '\u1e3d'), ('\u1e3f',
+ '\u1e3f'), ('\u1e41', '\u1e41'), ('\u1e43', '\u1e43'), ('\u1e45', '\u1e45'), ('\u1e47',
+ '\u1e47'), ('\u1e49', '\u1e49'), ('\u1e4b', '\u1e4b'), ('\u1e4d', '\u1e4d'), ('\u1e4f',
+ '\u1e4f'), ('\u1e51', '\u1e51'), ('\u1e53', '\u1e53'), ('\u1e55', '\u1e55'), ('\u1e57',
+ '\u1e57'), ('\u1e59', '\u1e59'), ('\u1e5b', '\u1e5b'), ('\u1e5d', '\u1e5d'), ('\u1e5f',
+ '\u1e5f'), ('\u1e61', '\u1e61'), ('\u1e63', '\u1e63'), ('\u1e65', '\u1e65'), ('\u1e67',
+ '\u1e67'), ('\u1e69', '\u1e69'), ('\u1e6b', '\u1e6b'), ('\u1e6d', '\u1e6d'), ('\u1e6f',
+ '\u1e6f'), ('\u1e71', '\u1e71'), ('\u1e73', '\u1e73'), ('\u1e75', '\u1e75'), ('\u1e77',
+ '\u1e77'), ('\u1e79', '\u1e79'), ('\u1e7b', '\u1e7b'), ('\u1e7d', '\u1e7d'), ('\u1e7f',
+ '\u1e7f'), ('\u1e81', '\u1e81'), ('\u1e83', '\u1e83'), ('\u1e85', '\u1e85'), ('\u1e87',
+ '\u1e87'), ('\u1e89', '\u1e89'), ('\u1e8b', '\u1e8b'), ('\u1e8d', '\u1e8d'), ('\u1e8f',
+ '\u1e8f'), ('\u1e91', '\u1e91'), ('\u1e93', '\u1e93'), ('\u1e95', '\u1e9d'), ('\u1e9f',
+ '\u1e9f'), ('\u1ea1', '\u1ea1'), ('\u1ea3', '\u1ea3'), ('\u1ea5', '\u1ea5'), ('\u1ea7',
+ '\u1ea7'), ('\u1ea9', '\u1ea9'), ('\u1eab', '\u1eab'), ('\u1ead', '\u1ead'), ('\u1eaf',
+ '\u1eaf'), ('\u1eb1', '\u1eb1'), ('\u1eb3', '\u1eb3'), ('\u1eb5', '\u1eb5'), ('\u1eb7',
+ '\u1eb7'), ('\u1eb9', '\u1eb9'), ('\u1ebb', '\u1ebb'), ('\u1ebd', '\u1ebd'), ('\u1ebf',
+ '\u1ebf'), ('\u1ec1', '\u1ec1'), ('\u1ec3', '\u1ec3'), ('\u1ec5', '\u1ec5'), ('\u1ec7',
+ '\u1ec7'), ('\u1ec9', '\u1ec9'), ('\u1ecb', '\u1ecb'), ('\u1ecd', '\u1ecd'), ('\u1ecf',
+ '\u1ecf'), ('\u1ed1', '\u1ed1'), ('\u1ed3', '\u1ed3'), ('\u1ed5', '\u1ed5'), ('\u1ed7',
+ '\u1ed7'), ('\u1ed9', '\u1ed9'), ('\u1edb', '\u1edb'), ('\u1edd', '\u1edd'), ('\u1edf',
+ '\u1edf'), ('\u1ee1', '\u1ee1'), ('\u1ee3', '\u1ee3'), ('\u1ee5', '\u1ee5'), ('\u1ee7',
+ '\u1ee7'), ('\u1ee9', '\u1ee9'), ('\u1eeb', '\u1eeb'), ('\u1eed', '\u1eed'), ('\u1eef',
+ '\u1eef'), ('\u1ef1', '\u1ef1'), ('\u1ef3', '\u1ef3'), ('\u1ef5', '\u1ef5'), ('\u1ef7',
+ '\u1ef7'), ('\u1ef9', '\u1ef9'), ('\u1efb', '\u1efb'), ('\u1efd', '\u1efd'), ('\u1eff',
+ '\u1f07'), ('\u1f10', '\u1f15'), ('\u1f20', '\u1f27'), ('\u1f30', '\u1f37'), ('\u1f40',
+ '\u1f45'), ('\u1f50', '\u1f57'), ('\u1f60', '\u1f67'), ('\u1f70', '\u1f7d'), ('\u1f80',
+ '\u1f87'), ('\u1f90', '\u1f97'), ('\u1fa0', '\u1fa7'), ('\u1fb0', '\u1fb4'), ('\u1fb6',
+ '\u1fb7'), ('\u1fbe', '\u1fbe'), ('\u1fc2', '\u1fc4'), ('\u1fc6', '\u1fc7'), ('\u1fd0',
+ '\u1fd3'), ('\u1fd6', '\u1fd7'), ('\u1fe0', '\u1fe7'), ('\u1ff2', '\u1ff4'), ('\u1ff6',
+ '\u1ff7'), ('\u210a', '\u210a'), ('\u210e', '\u210f'), ('\u2113', '\u2113'), ('\u212f',
+ '\u212f'), ('\u2134', '\u2134'), ('\u2139', '\u2139'), ('\u213c', '\u213d'), ('\u2146',
+ '\u2149'), ('\u214e', '\u214e'), ('\u2184', '\u2184'), ('\u2c30', '\u2c5e'), ('\u2c61',
+ '\u2c61'), ('\u2c65', '\u2c66'), ('\u2c68', '\u2c68'), ('\u2c6a', '\u2c6a'), ('\u2c6c',
+ '\u2c6c'), ('\u2c71', '\u2c71'), ('\u2c73', '\u2c74'), ('\u2c76', '\u2c7b'), ('\u2c81',
+ '\u2c81'), ('\u2c83', '\u2c83'), ('\u2c85', '\u2c85'), ('\u2c87', '\u2c87'), ('\u2c89',
+ '\u2c89'), ('\u2c8b', '\u2c8b'), ('\u2c8d', '\u2c8d'), ('\u2c8f', '\u2c8f'), ('\u2c91',
+ '\u2c91'), ('\u2c93', '\u2c93'), ('\u2c95', '\u2c95'), ('\u2c97', '\u2c97'), ('\u2c99',
+ '\u2c99'), ('\u2c9b', '\u2c9b'), ('\u2c9d', '\u2c9d'), ('\u2c9f', '\u2c9f'), ('\u2ca1',
+ '\u2ca1'), ('\u2ca3', '\u2ca3'), ('\u2ca5', '\u2ca5'), ('\u2ca7', '\u2ca7'), ('\u2ca9',
+ '\u2ca9'), ('\u2cab', '\u2cab'), ('\u2cad', '\u2cad'), ('\u2caf', '\u2caf'), ('\u2cb1',
+ '\u2cb1'), ('\u2cb3', '\u2cb3'), ('\u2cb5', '\u2cb5'), ('\u2cb7', '\u2cb7'), ('\u2cb9',
+ '\u2cb9'), ('\u2cbb', '\u2cbb'), ('\u2cbd', '\u2cbd'), ('\u2cbf', '\u2cbf'), ('\u2cc1',
+ '\u2cc1'), ('\u2cc3', '\u2cc3'), ('\u2cc5', '\u2cc5'), ('\u2cc7', '\u2cc7'), ('\u2cc9',
+ '\u2cc9'), ('\u2ccb', '\u2ccb'), ('\u2ccd', '\u2ccd'), ('\u2ccf', '\u2ccf'), ('\u2cd1',
+ '\u2cd1'), ('\u2cd3', '\u2cd3'), ('\u2cd5', '\u2cd5'), ('\u2cd7', '\u2cd7'), ('\u2cd9',
+ '\u2cd9'), ('\u2cdb', '\u2cdb'), ('\u2cdd', '\u2cdd'), ('\u2cdf', '\u2cdf'), ('\u2ce1',
+ '\u2ce1'), ('\u2ce3', '\u2ce4'), ('\u2cec', '\u2cec'), ('\u2cee', '\u2cee'), ('\u2cf3',
+ '\u2cf3'), ('\u2d00', '\u2d25'), ('\u2d27', '\u2d27'), ('\u2d2d', '\u2d2d'), ('\ua641',
+ '\ua641'), ('\ua643', '\ua643'), ('\ua645', '\ua645'), ('\ua647', '\ua647'), ('\ua649',
+ '\ua649'), ('\ua64b', '\ua64b'), ('\ua64d', '\ua64d'), ('\ua64f', '\ua64f'), ('\ua651',
+ '\ua651'), ('\ua653', '\ua653'), ('\ua655', '\ua655'), ('\ua657', '\ua657'), ('\ua659',
+ '\ua659'), ('\ua65b', '\ua65b'), ('\ua65d', '\ua65d'), ('\ua65f', '\ua65f'), ('\ua661',
+ '\ua661'), ('\ua663', '\ua663'), ('\ua665', '\ua665'), ('\ua667', '\ua667'), ('\ua669',
+ '\ua669'), ('\ua66b', '\ua66b'), ('\ua66d', '\ua66d'), ('\ua681', '\ua681'), ('\ua683',
+ '\ua683'), ('\ua685', '\ua685'), ('\ua687', '\ua687'), ('\ua689', '\ua689'), ('\ua68b',
+ '\ua68b'), ('\ua68d', '\ua68d'), ('\ua68f', '\ua68f'), ('\ua691', '\ua691'), ('\ua693',
+ '\ua693'), ('\ua695', '\ua695'), ('\ua697', '\ua697'), ('\ua699', '\ua699'), ('\ua69b',
+ '\ua69b'), ('\ua723', '\ua723'), ('\ua725', '\ua725'), ('\ua727', '\ua727'), ('\ua729',
+ '\ua729'), ('\ua72b', '\ua72b'), ('\ua72d', '\ua72d'), ('\ua72f', '\ua731'), ('\ua733',
+ '\ua733'), ('\ua735', '\ua735'), ('\ua737', '\ua737'), ('\ua739', '\ua739'), ('\ua73b',
+ '\ua73b'), ('\ua73d', '\ua73d'), ('\ua73f', '\ua73f'), ('\ua741', '\ua741'), ('\ua743',
+ '\ua743'), ('\ua745', '\ua745'), ('\ua747', '\ua747'), ('\ua749', '\ua749'), ('\ua74b',
+ '\ua74b'), ('\ua74d', '\ua74d'), ('\ua74f', '\ua74f'), ('\ua751', '\ua751'), ('\ua753',
+ '\ua753'), ('\ua755', '\ua755'), ('\ua757', '\ua757'), ('\ua759', '\ua759'), ('\ua75b',
+ '\ua75b'), ('\ua75d', '\ua75d'), ('\ua75f', '\ua75f'), ('\ua761', '\ua761'), ('\ua763',
+ '\ua763'), ('\ua765', '\ua765'), ('\ua767', '\ua767'), ('\ua769', '\ua769'), ('\ua76b',
+ '\ua76b'), ('\ua76d', '\ua76d'), ('\ua76f', '\ua76f'), ('\ua771', '\ua778'), ('\ua77a',
+ '\ua77a'), ('\ua77c', '\ua77c'), ('\ua77f', '\ua77f'), ('\ua781', '\ua781'), ('\ua783',
+ '\ua783'), ('\ua785', '\ua785'), ('\ua787', '\ua787'), ('\ua78c', '\ua78c'), ('\ua78e',
+ '\ua78e'), ('\ua791', '\ua791'), ('\ua793', '\ua795'), ('\ua797', '\ua797'), ('\ua799',
+ '\ua799'), ('\ua79b', '\ua79b'), ('\ua79d', '\ua79d'), ('\ua79f', '\ua79f'), ('\ua7a1',
+ '\ua7a1'), ('\ua7a3', '\ua7a3'), ('\ua7a5', '\ua7a5'), ('\ua7a7', '\ua7a7'), ('\ua7a9',
+ '\ua7a9'), ('\ua7fa', '\ua7fa'), ('\uab30', '\uab5a'), ('\uab64', '\uab65'), ('\ufb00',
+ '\ufb06'), ('\ufb13', '\ufb17'), ('\uff41', '\uff5a'), ('\U00010428', '\U0001044f'),
+ ('\U000118c0', '\U000118df'), ('\U0001d41a', '\U0001d433'), ('\U0001d44e', '\U0001d454'),
+ ('\U0001d456', '\U0001d467'), ('\U0001d482', '\U0001d49b'), ('\U0001d4b6', '\U0001d4b9'),
+ ('\U0001d4bb', '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5', '\U0001d4cf'),
+ ('\U0001d4ea', '\U0001d503'), ('\U0001d51e', '\U0001d537'), ('\U0001d552', '\U0001d56b'),
+ ('\U0001d586', '\U0001d59f'), ('\U0001d5ba', '\U0001d5d3'), ('\U0001d5ee', '\U0001d607'),
+ ('\U0001d622', '\U0001d63b'), ('\U0001d656', '\U0001d66f'), ('\U0001d68a', '\U0001d6a5'),
+ ('\U0001d6c2', '\U0001d6da'), ('\U0001d6dc', '\U0001d6e1'), ('\U0001d6fc', '\U0001d714'),
+ ('\U0001d716', '\U0001d71b'), ('\U0001d736', '\U0001d74e'), ('\U0001d750', '\U0001d755'),
+ ('\U0001d770', '\U0001d788'), ('\U0001d78a', '\U0001d78f'), ('\U0001d7aa', '\U0001d7c2'),
+ ('\U0001d7c4', '\U0001d7c9'), ('\U0001d7cb', '\U0001d7cb')
+ ];
+
+ pub static Lm_table: &'static [(char, char)] = &[
+ ('\u02b0', '\u02c1'), ('\u02c6', '\u02d1'), ('\u02e0', '\u02e4'), ('\u02ec', '\u02ec'),
+ ('\u02ee', '\u02ee'), ('\u0374', '\u0374'), ('\u037a', '\u037a'), ('\u0559', '\u0559'),
+ ('\u0640', '\u0640'), ('\u06e5', '\u06e6'), ('\u07f4', '\u07f5'), ('\u07fa', '\u07fa'),
+ ('\u081a', '\u081a'), ('\u0824', '\u0824'), ('\u0828', '\u0828'), ('\u0971', '\u0971'),
+ ('\u0e46', '\u0e46'), ('\u0ec6', '\u0ec6'), ('\u10fc', '\u10fc'), ('\u17d7', '\u17d7'),
+ ('\u1843', '\u1843'), ('\u1aa7', '\u1aa7'), ('\u1c78', '\u1c7d'), ('\u1d2c', '\u1d6a'),
+ ('\u1d78', '\u1d78'), ('\u1d9b', '\u1dbf'), ('\u2071', '\u2071'), ('\u207f', '\u207f'),
+ ('\u2090', '\u209c'), ('\u2c7c', '\u2c7d'), ('\u2d6f', '\u2d6f'), ('\u2e2f', '\u2e2f'),
+ ('\u3005', '\u3005'), ('\u3031', '\u3035'), ('\u303b', '\u303b'), ('\u309d', '\u309e'),
+ ('\u30fc', '\u30fe'), ('\ua015', '\ua015'), ('\ua4f8', '\ua4fd'), ('\ua60c', '\ua60c'),
+ ('\ua67f', '\ua67f'), ('\ua69c', '\ua69d'), ('\ua717', '\ua71f'), ('\ua770', '\ua770'),
+ ('\ua788', '\ua788'), ('\ua7f8', '\ua7f9'), ('\ua9cf', '\ua9cf'), ('\ua9e6', '\ua9e6'),
+ ('\uaa70', '\uaa70'), ('\uaadd', '\uaadd'), ('\uaaf3', '\uaaf4'), ('\uab5c', '\uab5f'),
+ ('\uff70', '\uff70'), ('\uff9e', '\uff9f'), ('\U00016b40', '\U00016b43'), ('\U00016f93',
+ '\U00016f9f')
+ ];
+
+ pub static Lo_table: &'static [(char, char)] = &[
+ ('\xaa', '\xaa'), ('\xba', '\xba'), ('\u01bb', '\u01bb'), ('\u01c0', '\u01c3'), ('\u0294',
+ '\u0294'), ('\u05d0', '\u05ea'), ('\u05f0', '\u05f2'), ('\u0620', '\u063f'), ('\u0641',
+ '\u064a'), ('\u066e', '\u066f'), ('\u0671', '\u06d3'), ('\u06d5', '\u06d5'), ('\u06ee',
+ '\u06ef'), ('\u06fa', '\u06fc'), ('\u06ff', '\u06ff'), ('\u0710', '\u0710'), ('\u0712',
+ '\u072f'), ('\u074d', '\u07a5'), ('\u07b1', '\u07b1'), ('\u07ca', '\u07ea'), ('\u0800',
+ '\u0815'), ('\u0840', '\u0858'), ('\u08a0', '\u08b2'), ('\u0904', '\u0939'), ('\u093d',
+ '\u093d'), ('\u0950', '\u0950'), ('\u0958', '\u0961'), ('\u0972', '\u0980'), ('\u0985',
+ '\u098c'), ('\u098f', '\u0990'), ('\u0993', '\u09a8'), ('\u09aa', '\u09b0'), ('\u09b2',
+ '\u09b2'), ('\u09b6', '\u09b9'), ('\u09bd', '\u09bd'), ('\u09ce', '\u09ce'), ('\u09dc',
+ '\u09dd'), ('\u09df', '\u09e1'), ('\u09f0', '\u09f1'), ('\u0a05', '\u0a0a'), ('\u0a0f',
+ '\u0a10'), ('\u0a13', '\u0a28'), ('\u0a2a', '\u0a30'), ('\u0a32', '\u0a33'), ('\u0a35',
+ '\u0a36'), ('\u0a38', '\u0a39'), ('\u0a59', '\u0a5c'), ('\u0a5e', '\u0a5e'), ('\u0a72',
+ '\u0a74'), ('\u0a85', '\u0a8d'), ('\u0a8f', '\u0a91'), ('\u0a93', '\u0aa8'), ('\u0aaa',
+ '\u0ab0'), ('\u0ab2', '\u0ab3'), ('\u0ab5', '\u0ab9'), ('\u0abd', '\u0abd'), ('\u0ad0',
+ '\u0ad0'), ('\u0ae0', '\u0ae1'), ('\u0b05', '\u0b0c'), ('\u0b0f', '\u0b10'), ('\u0b13',
+ '\u0b28'), ('\u0b2a', '\u0b30'), ('\u0b32', '\u0b33'), ('\u0b35', '\u0b39'), ('\u0b3d',
+ '\u0b3d'), ('\u0b5c', '\u0b5d'), ('\u0b5f', '\u0b61'), ('\u0b71', '\u0b71'), ('\u0b83',
+ '\u0b83'), ('\u0b85', '\u0b8a'), ('\u0b8e', '\u0b90'), ('\u0b92', '\u0b95'), ('\u0b99',
+ '\u0b9a'), ('\u0b9c', '\u0b9c'), ('\u0b9e', '\u0b9f'), ('\u0ba3', '\u0ba4'), ('\u0ba8',
+ '\u0baa'), ('\u0bae', '\u0bb9'), ('\u0bd0', '\u0bd0'), ('\u0c05', '\u0c0c'), ('\u0c0e',
+ '\u0c10'), ('\u0c12', '\u0c28'), ('\u0c2a', '\u0c39'), ('\u0c3d', '\u0c3d'), ('\u0c58',
+ '\u0c59'), ('\u0c60', '\u0c61'), ('\u0c85', '\u0c8c'), ('\u0c8e', '\u0c90'), ('\u0c92',
+ '\u0ca8'), ('\u0caa', '\u0cb3'), ('\u0cb5', '\u0cb9'), ('\u0cbd', '\u0cbd'), ('\u0cde',
+ '\u0cde'), ('\u0ce0', '\u0ce1'), ('\u0cf1', '\u0cf2'), ('\u0d05', '\u0d0c'), ('\u0d0e',
+ '\u0d10'), ('\u0d12', '\u0d3a'), ('\u0d3d', '\u0d3d'), ('\u0d4e', '\u0d4e'), ('\u0d60',
+ '\u0d61'), ('\u0d7a', '\u0d7f'), ('\u0d85', '\u0d96'), ('\u0d9a', '\u0db1'), ('\u0db3',
+ '\u0dbb'), ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'), ('\u0e01', '\u0e30'), ('\u0e32',
+ '\u0e33'), ('\u0e40', '\u0e45'), ('\u0e81', '\u0e82'), ('\u0e84', '\u0e84'), ('\u0e87',
+ '\u0e88'), ('\u0e8a', '\u0e8a'), ('\u0e8d', '\u0e8d'), ('\u0e94', '\u0e97'), ('\u0e99',
+ '\u0e9f'), ('\u0ea1', '\u0ea3'), ('\u0ea5', '\u0ea5'), ('\u0ea7', '\u0ea7'), ('\u0eaa',
+ '\u0eab'), ('\u0ead', '\u0eb0'), ('\u0eb2', '\u0eb3'), ('\u0ebd', '\u0ebd'), ('\u0ec0',
+ '\u0ec4'), ('\u0edc', '\u0edf'), ('\u0f00', '\u0f00'), ('\u0f40', '\u0f47'), ('\u0f49',
+ '\u0f6c'), ('\u0f88', '\u0f8c'), ('\u1000', '\u102a'), ('\u103f', '\u103f'), ('\u1050',
+ '\u1055'), ('\u105a', '\u105d'), ('\u1061', '\u1061'), ('\u1065', '\u1066'), ('\u106e',
+ '\u1070'), ('\u1075', '\u1081'), ('\u108e', '\u108e'), ('\u10d0', '\u10fa'), ('\u10fd',
+ '\u1248'), ('\u124a', '\u124d'), ('\u1250', '\u1256'), ('\u1258', '\u1258'), ('\u125a',
+ '\u125d'), ('\u1260', '\u1288'), ('\u128a', '\u128d'), ('\u1290', '\u12b0'), ('\u12b2',
+ '\u12b5'), ('\u12b8', '\u12be'), ('\u12c0', '\u12c0'), ('\u12c2', '\u12c5'), ('\u12c8',
+ '\u12d6'), ('\u12d8', '\u1310'), ('\u1312', '\u1315'), ('\u1318', '\u135a'), ('\u1380',
+ '\u138f'), ('\u13a0', '\u13f4'), ('\u1401', '\u166c'), ('\u166f', '\u167f'), ('\u1681',
+ '\u169a'), ('\u16a0', '\u16ea'), ('\u16f1', '\u16f8'), ('\u1700', '\u170c'), ('\u170e',
+ '\u1711'), ('\u1720', '\u1731'), ('\u1740', '\u1751'), ('\u1760', '\u176c'), ('\u176e',
+ '\u1770'), ('\u1780', '\u17b3'), ('\u17dc', '\u17dc'), ('\u1820', '\u1842'), ('\u1844',
+ '\u1877'), ('\u1880', '\u18a8'), ('\u18aa', '\u18aa'), ('\u18b0', '\u18f5'), ('\u1900',
+ '\u191e'), ('\u1950', '\u196d'), ('\u1970', '\u1974'), ('\u1980', '\u19ab'), ('\u19c1',
+ '\u19c7'), ('\u1a00', '\u1a16'), ('\u1a20', '\u1a54'), ('\u1b05', '\u1b33'), ('\u1b45',
+ '\u1b4b'), ('\u1b83', '\u1ba0'), ('\u1bae', '\u1baf'), ('\u1bba', '\u1be5'), ('\u1c00',
+ '\u1c23'), ('\u1c4d', '\u1c4f'), ('\u1c5a', '\u1c77'), ('\u1ce9', '\u1cec'), ('\u1cee',
+ '\u1cf1'), ('\u1cf5', '\u1cf6'), ('\u2135', '\u2138'), ('\u2d30', '\u2d67'), ('\u2d80',
+ '\u2d96'), ('\u2da0', '\u2da6'), ('\u2da8', '\u2dae'), ('\u2db0', '\u2db6'), ('\u2db8',
+ '\u2dbe'), ('\u2dc0', '\u2dc6'), ('\u2dc8', '\u2dce'), ('\u2dd0', '\u2dd6'), ('\u2dd8',
+ '\u2dde'), ('\u3006', '\u3006'), ('\u303c', '\u303c'), ('\u3041', '\u3096'), ('\u309f',
+ '\u309f'), ('\u30a1', '\u30fa'), ('\u30ff', '\u30ff'), ('\u3105', '\u312d'), ('\u3131',
+ '\u318e'), ('\u31a0', '\u31ba'), ('\u31f0', '\u31ff'), ('\u3400', '\u3400'), ('\u4db5',
+ '\u4db5'), ('\u4e00', '\u4e00'), ('\u9fcc', '\u9fcc'), ('\ua000', '\ua014'), ('\ua016',
+ '\ua48c'), ('\ua4d0', '\ua4f7'), ('\ua500', '\ua60b'), ('\ua610', '\ua61f'), ('\ua62a',
+ '\ua62b'), ('\ua66e', '\ua66e'), ('\ua6a0', '\ua6e5'), ('\ua7f7', '\ua7f7'), ('\ua7fb',
+ '\ua801'), ('\ua803', '\ua805'), ('\ua807', '\ua80a'), ('\ua80c', '\ua822'), ('\ua840',
+ '\ua873'), ('\ua882', '\ua8b3'), ('\ua8f2', '\ua8f7'), ('\ua8fb', '\ua8fb'), ('\ua90a',
+ '\ua925'), ('\ua930', '\ua946'), ('\ua960', '\ua97c'), ('\ua984', '\ua9b2'), ('\ua9e0',
+ '\ua9e4'), ('\ua9e7', '\ua9ef'), ('\ua9fa', '\ua9fe'), ('\uaa00', '\uaa28'), ('\uaa40',
+ '\uaa42'), ('\uaa44', '\uaa4b'), ('\uaa60', '\uaa6f'), ('\uaa71', '\uaa76'), ('\uaa7a',
+ '\uaa7a'), ('\uaa7e', '\uaaaf'), ('\uaab1', '\uaab1'), ('\uaab5', '\uaab6'), ('\uaab9',
+ '\uaabd'), ('\uaac0', '\uaac0'), ('\uaac2', '\uaac2'), ('\uaadb', '\uaadc'), ('\uaae0',
+ '\uaaea'), ('\uaaf2', '\uaaf2'), ('\uab01', '\uab06'), ('\uab09', '\uab0e'), ('\uab11',
+ '\uab16'), ('\uab20', '\uab26'), ('\uab28', '\uab2e'), ('\uabc0', '\uabe2'), ('\uac00',
+ '\uac00'), ('\ud7a3', '\ud7a3'), ('\ud7b0', '\ud7c6'), ('\ud7cb', '\ud7fb'), ('\uf900',
+ '\ufa6d'), ('\ufa70', '\ufad9'), ('\ufb1d', '\ufb1d'), ('\ufb1f', '\ufb28'), ('\ufb2a',
+ '\ufb36'), ('\ufb38', '\ufb3c'), ('\ufb3e', '\ufb3e'), ('\ufb40', '\ufb41'), ('\ufb43',
+ '\ufb44'), ('\ufb46', '\ufbb1'), ('\ufbd3', '\ufd3d'), ('\ufd50', '\ufd8f'), ('\ufd92',
+ '\ufdc7'), ('\ufdf0', '\ufdfb'), ('\ufe70', '\ufe74'), ('\ufe76', '\ufefc'), ('\uff66',
+ '\uff6f'), ('\uff71', '\uff9d'), ('\uffa0', '\uffbe'), ('\uffc2', '\uffc7'), ('\uffca',
+ '\uffcf'), ('\uffd2', '\uffd7'), ('\uffda', '\uffdc'), ('\U00010000', '\U0001000b'),
+ ('\U0001000d', '\U00010026'), ('\U00010028', '\U0001003a'), ('\U0001003c', '\U0001003d'),
+ ('\U0001003f', '\U0001004d'), ('\U00010050', '\U0001005d'), ('\U00010080', '\U000100fa'),
+ ('\U00010280', '\U0001029c'), ('\U000102a0', '\U000102d0'), ('\U00010300', '\U0001031f'),
+ ('\U00010330', '\U00010340'), ('\U00010342', '\U00010349'), ('\U00010350', '\U00010375'),
+ ('\U00010380', '\U0001039d'), ('\U000103a0', '\U000103c3'), ('\U000103c8', '\U000103cf'),
+ ('\U00010450', '\U0001049d'), ('\U00010500', '\U00010527'), ('\U00010530', '\U00010563'),
+ ('\U00010600', '\U00010736'), ('\U00010740', '\U00010755'), ('\U00010760', '\U00010767'),
+ ('\U00010800', '\U00010805'), ('\U00010808', '\U00010808'), ('\U0001080a', '\U00010835'),
+ ('\U00010837', '\U00010838'), ('\U0001083c', '\U0001083c'), ('\U0001083f', '\U00010855'),
+ ('\U00010860', '\U00010876'), ('\U00010880', '\U0001089e'), ('\U00010900', '\U00010915'),
+ ('\U00010920', '\U00010939'), ('\U00010980', '\U000109b7'), ('\U000109be', '\U000109bf'),
+ ('\U00010a00', '\U00010a00'), ('\U00010a10', '\U00010a13'), ('\U00010a15', '\U00010a17'),
+ ('\U00010a19', '\U00010a33'), ('\U00010a60', '\U00010a7c'), ('\U00010a80', '\U00010a9c'),
+ ('\U00010ac0', '\U00010ac7'), ('\U00010ac9', '\U00010ae4'), ('\U00010b00', '\U00010b35'),
+ ('\U00010b40', '\U00010b55'), ('\U00010b60', '\U00010b72'), ('\U00010b80', '\U00010b91'),
+ ('\U00010c00', '\U00010c48'), ('\U00011003', '\U00011037'), ('\U00011083', '\U000110af'),
+ ('\U000110d0', '\U000110e8'), ('\U00011103', '\U00011126'), ('\U00011150', '\U00011172'),
+ ('\U00011176', '\U00011176'), ('\U00011183', '\U000111b2'), ('\U000111c1', '\U000111c4'),
+ ('\U000111da', '\U000111da'), ('\U00011200', '\U00011211'), ('\U00011213', '\U0001122b'),
+ ('\U000112b0', '\U000112de'), ('\U00011305', '\U0001130c'), ('\U0001130f', '\U00011310'),
+ ('\U00011313', '\U00011328'), ('\U0001132a', '\U00011330'), ('\U00011332', '\U00011333'),
+ ('\U00011335', '\U00011339'), ('\U0001133d', '\U0001133d'), ('\U0001135d', '\U00011361'),
+ ('\U00011480', '\U000114af'), ('\U000114c4', '\U000114c5'), ('\U000114c7', '\U000114c7'),
+ ('\U00011580', '\U000115ae'), ('\U00011600', '\U0001162f'), ('\U00011644', '\U00011644'),
+ ('\U00011680', '\U000116aa'), ('\U000118ff', '\U000118ff'), ('\U00011ac0', '\U00011af8'),
+ ('\U00012000', '\U00012398'), ('\U00013000', '\U0001342e'), ('\U00016800', '\U00016a38'),
+ ('\U00016a40', '\U00016a5e'), ('\U00016ad0', '\U00016aed'), ('\U00016b00', '\U00016b2f'),
+ ('\U00016b63', '\U00016b77'), ('\U00016b7d', '\U00016b8f'), ('\U00016f00', '\U00016f44'),
+ ('\U00016f50', '\U00016f50'), ('\U0001b000', '\U0001b001'), ('\U0001bc00', '\U0001bc6a'),
+ ('\U0001bc70', '\U0001bc7c'), ('\U0001bc80', '\U0001bc88'), ('\U0001bc90', '\U0001bc99'),
+ ('\U0001e800', '\U0001e8c4'), ('\U0001ee00', '\U0001ee03'), ('\U0001ee05', '\U0001ee1f'),
+ ('\U0001ee21', '\U0001ee22'), ('\U0001ee24', '\U0001ee24'), ('\U0001ee27', '\U0001ee27'),
+ ('\U0001ee29', '\U0001ee32'), ('\U0001ee34', '\U0001ee37'), ('\U0001ee39', '\U0001ee39'),
+ ('\U0001ee3b', '\U0001ee3b'), ('\U0001ee42', '\U0001ee42'), ('\U0001ee47', '\U0001ee47'),
+ ('\U0001ee49', '\U0001ee49'), ('\U0001ee4b', '\U0001ee4b'), ('\U0001ee4d', '\U0001ee4f'),
+ ('\U0001ee51', '\U0001ee52'), ('\U0001ee54', '\U0001ee54'), ('\U0001ee57', '\U0001ee57'),
+ ('\U0001ee59', '\U0001ee59'), ('\U0001ee5b', '\U0001ee5b'), ('\U0001ee5d', '\U0001ee5d'),
+ ('\U0001ee5f', '\U0001ee5f'), ('\U0001ee61', '\U0001ee62'), ('\U0001ee64', '\U0001ee64'),
+ ('\U0001ee67', '\U0001ee6a'), ('\U0001ee6c', '\U0001ee72'), ('\U0001ee74', '\U0001ee77'),
+ ('\U0001ee79', '\U0001ee7c'), ('\U0001ee7e', '\U0001ee7e'), ('\U0001ee80', '\U0001ee89'),
+ ('\U0001ee8b', '\U0001ee9b'), ('\U0001eea1', '\U0001eea3'), ('\U0001eea5', '\U0001eea9'),
+ ('\U0001eeab', '\U0001eebb'), ('\U00020000', '\U00020000'), ('\U0002a6d6', '\U0002a6d6'),
+ ('\U0002a700', '\U0002a700'), ('\U0002b734', '\U0002b734'), ('\U0002b740', '\U0002b740'),
+ ('\U0002b81d', '\U0002b81d'), ('\U0002f800', '\U0002fa1d')
+ ];
+
+ pub static Lt_table: &'static [(char, char)] = &[
+ ('\u01c5', '\u01c5'), ('\u01c8', '\u01c8'), ('\u01cb', '\u01cb'), ('\u01f2', '\u01f2'),
+ ('\u1f88', '\u1f8f'), ('\u1f98', '\u1f9f'), ('\u1fa8', '\u1faf'), ('\u1fbc', '\u1fbc'),
+ ('\u1fcc', '\u1fcc'), ('\u1ffc', '\u1ffc')
+ ];
+
+ pub static Lu_table: &'static [(char, char)] = &[
+ ('\x41', '\x5a'), ('\xc0', '\xd6'), ('\xd8', '\xde'), ('\u0100', '\u0100'), ('\u0102',
+ '\u0102'), ('\u0104', '\u0104'), ('\u0106', '\u0106'), ('\u0108', '\u0108'), ('\u010a',
+ '\u010a'), ('\u010c', '\u010c'), ('\u010e', '\u010e'), ('\u0110', '\u0110'), ('\u0112',
+ '\u0112'), ('\u0114', '\u0114'), ('\u0116', '\u0116'), ('\u0118', '\u0118'), ('\u011a',
+ '\u011a'), ('\u011c', '\u011c'), ('\u011e', '\u011e'), ('\u0120', '\u0120'), ('\u0122',
+ '\u0122'), ('\u0124', '\u0124'), ('\u0126', '\u0126'), ('\u0128', '\u0128'), ('\u012a',
+ '\u012a'), ('\u012c', '\u012c'), ('\u012e', '\u012e'), ('\u0130', '\u0130'), ('\u0132',
+ '\u0132'), ('\u0134', '\u0134'), ('\u0136', '\u0136'), ('\u0139', '\u0139'), ('\u013b',
+ '\u013b'), ('\u013d', '\u013d'), ('\u013f', '\u013f'), ('\u0141', '\u0141'), ('\u0143',
+ '\u0143'), ('\u0145', '\u0145'), ('\u0147', '\u0147'), ('\u014a', '\u014a'), ('\u014c',
+ '\u014c'), ('\u014e', '\u014e'), ('\u0150', '\u0150'), ('\u0152', '\u0152'), ('\u0154',
+ '\u0154'), ('\u0156', '\u0156'), ('\u0158', '\u0158'), ('\u015a', '\u015a'), ('\u015c',
+ '\u015c'), ('\u015e', '\u015e'), ('\u0160', '\u0160'), ('\u0162', '\u0162'), ('\u0164',
+ '\u0164'), ('\u0166', '\u0166'), ('\u0168', '\u0168'), ('\u016a', '\u016a'), ('\u016c',
+ '\u016c'), ('\u016e', '\u016e'), ('\u0170', '\u0170'), ('\u0172', '\u0172'), ('\u0174',
+ '\u0174'), ('\u0176', '\u0176'), ('\u0178', '\u0179'), ('\u017b', '\u017b'), ('\u017d',
+ '\u017d'), ('\u0181', '\u0182'), ('\u0184', '\u0184'), ('\u0186', '\u0187'), ('\u0189',
+ '\u018b'), ('\u018e', '\u0191'), ('\u0193', '\u0194'), ('\u0196', '\u0198'), ('\u019c',
+ '\u019d'), ('\u019f', '\u01a0'), ('\u01a2', '\u01a2'), ('\u01a4', '\u01a4'), ('\u01a6',
+ '\u01a7'), ('\u01a9', '\u01a9'), ('\u01ac', '\u01ac'), ('\u01ae', '\u01af'), ('\u01b1',
+ '\u01b3'), ('\u01b5', '\u01b5'), ('\u01b7', '\u01b8'), ('\u01bc', '\u01bc'), ('\u01c4',
+ '\u01c4'), ('\u01c7', '\u01c7'), ('\u01ca', '\u01ca'), ('\u01cd', '\u01cd'), ('\u01cf',
+ '\u01cf'), ('\u01d1', '\u01d1'), ('\u01d3', '\u01d3'), ('\u01d5', '\u01d5'), ('\u01d7',
+ '\u01d7'), ('\u01d9', '\u01d9'), ('\u01db', '\u01db'), ('\u01de', '\u01de'), ('\u01e0',
+ '\u01e0'), ('\u01e2', '\u01e2'), ('\u01e4', '\u01e4'), ('\u01e6', '\u01e6'), ('\u01e8',
+ '\u01e8'), ('\u01ea', '\u01ea'), ('\u01ec', '\u01ec'), ('\u01ee', '\u01ee'), ('\u01f1',
+ '\u01f1'), ('\u01f4', '\u01f4'), ('\u01f6', '\u01f8'), ('\u01fa', '\u01fa'), ('\u01fc',
+ '\u01fc'), ('\u01fe', '\u01fe'), ('\u0200', '\u0200'), ('\u0202', '\u0202'), ('\u0204',
+ '\u0204'), ('\u0206', '\u0206'), ('\u0208', '\u0208'), ('\u020a', '\u020a'), ('\u020c',
+ '\u020c'), ('\u020e', '\u020e'), ('\u0210', '\u0210'), ('\u0212', '\u0212'), ('\u0214',
+ '\u0214'), ('\u0216', '\u0216'), ('\u0218', '\u0218'), ('\u021a', '\u021a'), ('\u021c',
+ '\u021c'), ('\u021e', '\u021e'), ('\u0220', '\u0220'), ('\u0222', '\u0222'), ('\u0224',
+ '\u0224'), ('\u0226', '\u0226'), ('\u0228', '\u0228'), ('\u022a', '\u022a'), ('\u022c',
+ '\u022c'), ('\u022e', '\u022e'), ('\u0230', '\u0230'), ('\u0232', '\u0232'), ('\u023a',
+ '\u023b'), ('\u023d', '\u023e'), ('\u0241', '\u0241'), ('\u0243', '\u0246'), ('\u0248',
+ '\u0248'), ('\u024a', '\u024a'), ('\u024c', '\u024c'), ('\u024e', '\u024e'), ('\u0370',
+ '\u0370'), ('\u0372', '\u0372'), ('\u0376', '\u0376'), ('\u037f', '\u037f'), ('\u0386',
+ '\u0386'), ('\u0388', '\u038a'), ('\u038c', '\u038c'), ('\u038e', '\u038f'), ('\u0391',
+ '\u03a1'), ('\u03a3', '\u03ab'), ('\u03cf', '\u03cf'), ('\u03d2', '\u03d4'), ('\u03d8',
+ '\u03d8'), ('\u03da', '\u03da'), ('\u03dc', '\u03dc'), ('\u03de', '\u03de'), ('\u03e0',
+ '\u03e0'), ('\u03e2', '\u03e2'), ('\u03e4', '\u03e4'), ('\u03e6', '\u03e6'), ('\u03e8',
+ '\u03e8'), ('\u03ea', '\u03ea'), ('\u03ec', '\u03ec'), ('\u03ee', '\u03ee'), ('\u03f4',
+ '\u03f4'), ('\u03f7', '\u03f7'), ('\u03f9', '\u03fa'), ('\u03fd', '\u042f'), ('\u0460',
+ '\u0460'), ('\u0462', '\u0462'), ('\u0464', '\u0464'), ('\u0466', '\u0466'), ('\u0468',
+ '\u0468'), ('\u046a', '\u046a'), ('\u046c', '\u046c'), ('\u046e', '\u046e'), ('\u0470',
+ '\u0470'), ('\u0472', '\u0472'), ('\u0474', '\u0474'), ('\u0476', '\u0476'), ('\u0478',
+ '\u0478'), ('\u047a', '\u047a'), ('\u047c', '\u047c'), ('\u047e', '\u047e'), ('\u0480',
+ '\u0480'), ('\u048a', '\u048a'), ('\u048c', '\u048c'), ('\u048e', '\u048e'), ('\u0490',
+ '\u0490'), ('\u0492', '\u0492'), ('\u0494', '\u0494'), ('\u0496', '\u0496'), ('\u0498',
+ '\u0498'), ('\u049a', '\u049a'), ('\u049c', '\u049c'), ('\u049e', '\u049e'), ('\u04a0',
+ '\u04a0'), ('\u04a2', '\u04a2'), ('\u04a4', '\u04a4'), ('\u04a6', '\u04a6'), ('\u04a8',
+ '\u04a8'), ('\u04aa', '\u04aa'), ('\u04ac', '\u04ac'), ('\u04ae', '\u04ae'), ('\u04b0',
+ '\u04b0'), ('\u04b2', '\u04b2'), ('\u04b4', '\u04b4'), ('\u04b6', '\u04b6'), ('\u04b8',
+ '\u04b8'), ('\u04ba', '\u04ba'), ('\u04bc', '\u04bc'), ('\u04be', '\u04be'), ('\u04c0',
+ '\u04c1'), ('\u04c3', '\u04c3'), ('\u04c5', '\u04c5'), ('\u04c7', '\u04c7'), ('\u04c9',
+ '\u04c9'), ('\u04cb', '\u04cb'), ('\u04cd', '\u04cd'), ('\u04d0', '\u04d0'), ('\u04d2',
+ '\u04d2'), ('\u04d4', '\u04d4'), ('\u04d6', '\u04d6'), ('\u04d8', '\u04d8'), ('\u04da',
+ '\u04da'), ('\u04dc', '\u04dc'), ('\u04de', '\u04de'), ('\u04e0', '\u04e0'), ('\u04e2',
+ '\u04e2'), ('\u04e4', '\u04e4'), ('\u04e6', '\u04e6'), ('\u04e8', '\u04e8'), ('\u04ea',
+ '\u04ea'), ('\u04ec', '\u04ec'), ('\u04ee', '\u04ee'), ('\u04f0', '\u04f0'), ('\u04f2',
+ '\u04f2'), ('\u04f4', '\u04f4'), ('\u04f6', '\u04f6'), ('\u04f8', '\u04f8'), ('\u04fa',
+ '\u04fa'), ('\u04fc', '\u04fc'), ('\u04fe', '\u04fe'), ('\u0500', '\u0500'), ('\u0502',
+ '\u0502'), ('\u0504', '\u0504'), ('\u0506', '\u0506'), ('\u0508', '\u0508'), ('\u050a',
+ '\u050a'), ('\u050c', '\u050c'), ('\u050e', '\u050e'), ('\u0510', '\u0510'), ('\u0512',
+ '\u0512'), ('\u0514', '\u0514'), ('\u0516', '\u0516'), ('\u0518', '\u0518'), ('\u051a',
+ '\u051a'), ('\u051c', '\u051c'), ('\u051e', '\u051e'), ('\u0520', '\u0520'), ('\u0522',
+ '\u0522'), ('\u0524', '\u0524'), ('\u0526', '\u0526'), ('\u0528', '\u0528'), ('\u052a',
+ '\u052a'), ('\u052c', '\u052c'), ('\u052e', '\u052e'), ('\u0531', '\u0556'), ('\u10a0',
+ '\u10c5'), ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'), ('\u1e00', '\u1e00'), ('\u1e02',
+ '\u1e02'), ('\u1e04', '\u1e04'), ('\u1e06', '\u1e06'), ('\u1e08', '\u1e08'), ('\u1e0a',
+ '\u1e0a'), ('\u1e0c', '\u1e0c'), ('\u1e0e', '\u1e0e'), ('\u1e10', '\u1e10'), ('\u1e12',
+ '\u1e12'), ('\u1e14', '\u1e14'), ('\u1e16', '\u1e16'), ('\u1e18', '\u1e18'), ('\u1e1a',
+ '\u1e1a'), ('\u1e1c', '\u1e1c'), ('\u1e1e', '\u1e1e'), ('\u1e20', '\u1e20'), ('\u1e22',
+ '\u1e22'), ('\u1e24', '\u1e24'), ('\u1e26', '\u1e26'), ('\u1e28', '\u1e28'), ('\u1e2a',
+ '\u1e2a'), ('\u1e2c', '\u1e2c'), ('\u1e2e', '\u1e2e'), ('\u1e30', '\u1e30'), ('\u1e32',
+ '\u1e32'), ('\u1e34', '\u1e34'), ('\u1e36', '\u1e36'), ('\u1e38', '\u1e38'), ('\u1e3a',
+ '\u1e3a'), ('\u1e3c', '\u1e3c'), ('\u1e3e', '\u1e3e'), ('\u1e40', '\u1e40'), ('\u1e42',
+ '\u1e42'), ('\u1e44', '\u1e44'), ('\u1e46', '\u1e46'), ('\u1e48', '\u1e48'), ('\u1e4a',
+ '\u1e4a'), ('\u1e4c', '\u1e4c'), ('\u1e4e', '\u1e4e'), ('\u1e50', '\u1e50'), ('\u1e52',
+ '\u1e52'), ('\u1e54', '\u1e54'), ('\u1e56', '\u1e56'), ('\u1e58', '\u1e58'), ('\u1e5a',
+ '\u1e5a'), ('\u1e5c', '\u1e5c'), ('\u1e5e', '\u1e5e'), ('\u1e60', '\u1e60'), ('\u1e62',
+ '\u1e62'), ('\u1e64', '\u1e64'), ('\u1e66', '\u1e66'), ('\u1e68', '\u1e68'), ('\u1e6a',
+ '\u1e6a'), ('\u1e6c', '\u1e6c'), ('\u1e6e', '\u1e6e'), ('\u1e70', '\u1e70'), ('\u1e72',
+ '\u1e72'), ('\u1e74', '\u1e74'), ('\u1e76', '\u1e76'), ('\u1e78', '\u1e78'), ('\u1e7a',
+ '\u1e7a'), ('\u1e7c', '\u1e7c'), ('\u1e7e', '\u1e7e'), ('\u1e80', '\u1e80'), ('\u1e82',
+ '\u1e82'), ('\u1e84', '\u1e84'), ('\u1e86', '\u1e86'), ('\u1e88', '\u1e88'), ('\u1e8a',
+ '\u1e8a'), ('\u1e8c', '\u1e8c'), ('\u1e8e', '\u1e8e'), ('\u1e90', '\u1e90'), ('\u1e92',
+ '\u1e92'), ('\u1e94', '\u1e94'), ('\u1e9e', '\u1e9e'), ('\u1ea0', '\u1ea0'), ('\u1ea2',
+ '\u1ea2'), ('\u1ea4', '\u1ea4'), ('\u1ea6', '\u1ea6'), ('\u1ea8', '\u1ea8'), ('\u1eaa',
+ '\u1eaa'), ('\u1eac', '\u1eac'), ('\u1eae', '\u1eae'), ('\u1eb0', '\u1eb0'), ('\u1eb2',
+ '\u1eb2'), ('\u1eb4', '\u1eb4'), ('\u1eb6', '\u1eb6'), ('\u1eb8', '\u1eb8'), ('\u1eba',
+ '\u1eba'), ('\u1ebc', '\u1ebc'), ('\u1ebe', '\u1ebe'), ('\u1ec0', '\u1ec0'), ('\u1ec2',
+ '\u1ec2'), ('\u1ec4', '\u1ec4'), ('\u1ec6', '\u1ec6'), ('\u1ec8', '\u1ec8'), ('\u1eca',
+ '\u1eca'), ('\u1ecc', '\u1ecc'), ('\u1ece', '\u1ece'), ('\u1ed0', '\u1ed0'), ('\u1ed2',
+ '\u1ed2'), ('\u1ed4', '\u1ed4'), ('\u1ed6', '\u1ed6'), ('\u1ed8', '\u1ed8'), ('\u1eda',
+ '\u1eda'), ('\u1edc', '\u1edc'), ('\u1ede', '\u1ede'), ('\u1ee0', '\u1ee0'), ('\u1ee2',
+ '\u1ee2'), ('\u1ee4', '\u1ee4'), ('\u1ee6', '\u1ee6'), ('\u1ee8', '\u1ee8'), ('\u1eea',
+ '\u1eea'), ('\u1eec', '\u1eec'), ('\u1eee', '\u1eee'), ('\u1ef0', '\u1ef0'), ('\u1ef2',
+ '\u1ef2'), ('\u1ef4', '\u1ef4'), ('\u1ef6', '\u1ef6'), ('\u1ef8', '\u1ef8'), ('\u1efa',
+ '\u1efa'), ('\u1efc', '\u1efc'), ('\u1efe', '\u1efe'), ('\u1f08', '\u1f0f'), ('\u1f18',
+ '\u1f1d'), ('\u1f28', '\u1f2f'), ('\u1f38', '\u1f3f'), ('\u1f48', '\u1f4d'), ('\u1f59',
+ '\u1f59'), ('\u1f5b', '\u1f5b'), ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f5f'), ('\u1f68',
+ '\u1f6f'), ('\u1fb8', '\u1fbb'), ('\u1fc8', '\u1fcb'), ('\u1fd8', '\u1fdb'), ('\u1fe8',
+ '\u1fec'), ('\u1ff8', '\u1ffb'), ('\u2102', '\u2102'), ('\u2107', '\u2107'), ('\u210b',
+ '\u210d'), ('\u2110', '\u2112'), ('\u2115', '\u2115'), ('\u2119', '\u211d'), ('\u2124',
+ '\u2124'), ('\u2126', '\u2126'), ('\u2128', '\u2128'), ('\u212a', '\u212d'), ('\u2130',
+ '\u2133'), ('\u213e', '\u213f'), ('\u2145', '\u2145'), ('\u2183', '\u2183'), ('\u2c00',
+ '\u2c2e'), ('\u2c60', '\u2c60'), ('\u2c62', '\u2c64'), ('\u2c67', '\u2c67'), ('\u2c69',
+ '\u2c69'), ('\u2c6b', '\u2c6b'), ('\u2c6d', '\u2c70'), ('\u2c72', '\u2c72'), ('\u2c75',
+ '\u2c75'), ('\u2c7e', '\u2c80'), ('\u2c82', '\u2c82'), ('\u2c84', '\u2c84'), ('\u2c86',
+ '\u2c86'), ('\u2c88', '\u2c88'), ('\u2c8a', '\u2c8a'), ('\u2c8c', '\u2c8c'), ('\u2c8e',
+ '\u2c8e'), ('\u2c90', '\u2c90'), ('\u2c92', '\u2c92'), ('\u2c94', '\u2c94'), ('\u2c96',
+ '\u2c96'), ('\u2c98', '\u2c98'), ('\u2c9a', '\u2c9a'), ('\u2c9c', '\u2c9c'), ('\u2c9e',
+ '\u2c9e'), ('\u2ca0', '\u2ca0'), ('\u2ca2', '\u2ca2'), ('\u2ca4', '\u2ca4'), ('\u2ca6',
+ '\u2ca6'), ('\u2ca8', '\u2ca8'), ('\u2caa', '\u2caa'), ('\u2cac', '\u2cac'), ('\u2cae',
+ '\u2cae'), ('\u2cb0', '\u2cb0'), ('\u2cb2', '\u2cb2'), ('\u2cb4', '\u2cb4'), ('\u2cb6',
+ '\u2cb6'), ('\u2cb8', '\u2cb8'), ('\u2cba', '\u2cba'), ('\u2cbc', '\u2cbc'), ('\u2cbe',
+ '\u2cbe'), ('\u2cc0', '\u2cc0'), ('\u2cc2', '\u2cc2'), ('\u2cc4', '\u2cc4'), ('\u2cc6',
+ '\u2cc6'), ('\u2cc8', '\u2cc8'), ('\u2cca', '\u2cca'), ('\u2ccc', '\u2ccc'), ('\u2cce',
+ '\u2cce'), ('\u2cd0', '\u2cd0'), ('\u2cd2', '\u2cd2'), ('\u2cd4', '\u2cd4'), ('\u2cd6',
+ '\u2cd6'), ('\u2cd8', '\u2cd8'), ('\u2cda', '\u2cda'), ('\u2cdc', '\u2cdc'), ('\u2cde',
+ '\u2cde'), ('\u2ce0', '\u2ce0'), ('\u2ce2', '\u2ce2'), ('\u2ceb', '\u2ceb'), ('\u2ced',
+ '\u2ced'), ('\u2cf2', '\u2cf2'), ('\ua640', '\ua640'), ('\ua642', '\ua642'), ('\ua644',
+ '\ua644'), ('\ua646', '\ua646'), ('\ua648', '\ua648'), ('\ua64a', '\ua64a'), ('\ua64c',
+ '\ua64c'), ('\ua64e', '\ua64e'), ('\ua650', '\ua650'), ('\ua652', '\ua652'), ('\ua654',
+ '\ua654'), ('\ua656', '\ua656'), ('\ua658', '\ua658'), ('\ua65a', '\ua65a'), ('\ua65c',
+ '\ua65c'), ('\ua65e', '\ua65e'), ('\ua660', '\ua660'), ('\ua662', '\ua662'), ('\ua664',
+ '\ua664'), ('\ua666', '\ua666'), ('\ua668', '\ua668'), ('\ua66a', '\ua66a'), ('\ua66c',
+ '\ua66c'), ('\ua680', '\ua680'), ('\ua682', '\ua682'), ('\ua684', '\ua684'), ('\ua686',
+ '\ua686'), ('\ua688', '\ua688'), ('\ua68a', '\ua68a'), ('\ua68c', '\ua68c'), ('\ua68e',
+ '\ua68e'), ('\ua690', '\ua690'), ('\ua692', '\ua692'), ('\ua694', '\ua694'), ('\ua696',
+ '\ua696'), ('\ua698', '\ua698'), ('\ua69a', '\ua69a'), ('\ua722', '\ua722'), ('\ua724',
+ '\ua724'), ('\ua726', '\ua726'), ('\ua728', '\ua728'), ('\ua72a', '\ua72a'), ('\ua72c',
+ '\ua72c'), ('\ua72e', '\ua72e'), ('\ua732', '\ua732'), ('\ua734', '\ua734'), ('\ua736',
+ '\ua736'), ('\ua738', '\ua738'), ('\ua73a', '\ua73a'), ('\ua73c', '\ua73c'), ('\ua73e',
+ '\ua73e'), ('\ua740', '\ua740'), ('\ua742', '\ua742'), ('\ua744', '\ua744'), ('\ua746',
+ '\ua746'), ('\ua748', '\ua748'), ('\ua74a', '\ua74a'), ('\ua74c', '\ua74c'), ('\ua74e',
+ '\ua74e'), ('\ua750', '\ua750'), ('\ua752', '\ua752'), ('\ua754', '\ua754'), ('\ua756',
+ '\ua756'), ('\ua758', '\ua758'), ('\ua75a', '\ua75a'), ('\ua75c', '\ua75c'), ('\ua75e',
+ '\ua75e'), ('\ua760', '\ua760'), ('\ua762', '\ua762'), ('\ua764', '\ua764'), ('\ua766',
+ '\ua766'), ('\ua768', '\ua768'), ('\ua76a', '\ua76a'), ('\ua76c', '\ua76c'), ('\ua76e',
+ '\ua76e'), ('\ua779', '\ua779'), ('\ua77b', '\ua77b'), ('\ua77d', '\ua77e'), ('\ua780',
+ '\ua780'), ('\ua782', '\ua782'), ('\ua784', '\ua784'), ('\ua786', '\ua786'), ('\ua78b',
+ '\ua78b'), ('\ua78d', '\ua78d'), ('\ua790', '\ua790'), ('\ua792', '\ua792'), ('\ua796',
+ '\ua796'), ('\ua798', '\ua798'), ('\ua79a', '\ua79a'), ('\ua79c', '\ua79c'), ('\ua79e',
+ '\ua79e'), ('\ua7a0', '\ua7a0'), ('\ua7a2', '\ua7a2'), ('\ua7a4', '\ua7a4'), ('\ua7a6',
+ '\ua7a6'), ('\ua7a8', '\ua7a8'), ('\ua7aa', '\ua7ad'), ('\ua7b0', '\ua7b1'), ('\uff21',
+ '\uff3a'), ('\U00010400', '\U00010427'), ('\U000118a0', '\U000118bf'), ('\U0001d400',
+ '\U0001d419'), ('\U0001d434', '\U0001d44d'), ('\U0001d468', '\U0001d481'), ('\U0001d49c',
+ '\U0001d49c'), ('\U0001d49e', '\U0001d49f'), ('\U0001d4a2', '\U0001d4a2'), ('\U0001d4a5',
+ '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'), ('\U0001d4ae', '\U0001d4b5'), ('\U0001d4d0',
+ '\U0001d4e9'), ('\U0001d504', '\U0001d505'), ('\U0001d507', '\U0001d50a'), ('\U0001d50d',
+ '\U0001d514'), ('\U0001d516', '\U0001d51c'), ('\U0001d538', '\U0001d539'), ('\U0001d53b',
+ '\U0001d53e'), ('\U0001d540', '\U0001d544'), ('\U0001d546', '\U0001d546'), ('\U0001d54a',
+ '\U0001d550'), ('\U0001d56c', '\U0001d585'), ('\U0001d5a0', '\U0001d5b9'), ('\U0001d5d4',
+ '\U0001d5ed'), ('\U0001d608', '\U0001d621'), ('\U0001d63c', '\U0001d655'), ('\U0001d670',
+ '\U0001d689'), ('\U0001d6a8', '\U0001d6c0'), ('\U0001d6e2', '\U0001d6fa'), ('\U0001d71c',
+ '\U0001d734'), ('\U0001d756', '\U0001d76e'), ('\U0001d790', '\U0001d7a8'), ('\U0001d7ca',
+ '\U0001d7ca')
+ ];
+
+ pub static M_table: &'static [(char, char)] = &[
+ ('\u0300', '\u036f'), ('\u0483', '\u0489'), ('\u0591', '\u05bd'), ('\u05bf', '\u05bf'),
+ ('\u05c1', '\u05c2'), ('\u05c4', '\u05c5'), ('\u05c7', '\u05c7'), ('\u0610', '\u061a'),
+ ('\u064b', '\u065f'), ('\u0670', '\u0670'), ('\u06d6', '\u06dc'), ('\u06df', '\u06e4'),
+ ('\u06e7', '\u06e8'), ('\u06ea', '\u06ed'), ('\u0711', '\u0711'), ('\u0730', '\u074a'),
+ ('\u07a6', '\u07b0'), ('\u07eb', '\u07f3'), ('\u0816', '\u0819'), ('\u081b', '\u0823'),
+ ('\u0825', '\u0827'), ('\u0829', '\u082d'), ('\u0859', '\u085b'), ('\u08e4', '\u0903'),
+ ('\u093a', '\u093c'), ('\u093e', '\u094f'), ('\u0951', '\u0957'), ('\u0962', '\u0963'),
+ ('\u0981', '\u0983'), ('\u09bc', '\u09bc'), ('\u09be', '\u09c4'), ('\u09c7', '\u09c8'),
+ ('\u09cb', '\u09cd'), ('\u09d7', '\u09d7'), ('\u09e2', '\u09e3'), ('\u0a01', '\u0a03'),
+ ('\u0a3c', '\u0a3c'), ('\u0a3e', '\u0a42'), ('\u0a47', '\u0a48'), ('\u0a4b', '\u0a4d'),
+ ('\u0a51', '\u0a51'), ('\u0a70', '\u0a71'), ('\u0a75', '\u0a75'), ('\u0a81', '\u0a83'),
+ ('\u0abc', '\u0abc'), ('\u0abe', '\u0ac5'), ('\u0ac7', '\u0ac9'), ('\u0acb', '\u0acd'),
+ ('\u0ae2', '\u0ae3'), ('\u0b01', '\u0b03'), ('\u0b3c', '\u0b3c'), ('\u0b3e', '\u0b44'),
+ ('\u0b47', '\u0b48'), ('\u0b4b', '\u0b4d'), ('\u0b56', '\u0b57'), ('\u0b62', '\u0b63'),
+ ('\u0b82', '\u0b82'), ('\u0bbe', '\u0bc2'), ('\u0bc6', '\u0bc8'), ('\u0bca', '\u0bcd'),
+ ('\u0bd7', '\u0bd7'), ('\u0c00', '\u0c03'), ('\u0c3e', '\u0c44'), ('\u0c46', '\u0c48'),
+ ('\u0c4a', '\u0c4d'), ('\u0c55', '\u0c56'), ('\u0c62', '\u0c63'), ('\u0c81', '\u0c83'),
+ ('\u0cbc', '\u0cbc'), ('\u0cbe', '\u0cc4'), ('\u0cc6', '\u0cc8'), ('\u0cca', '\u0ccd'),
+ ('\u0cd5', '\u0cd6'), ('\u0ce2', '\u0ce3'), ('\u0d01', '\u0d03'), ('\u0d3e', '\u0d44'),
+ ('\u0d46', '\u0d48'), ('\u0d4a', '\u0d4d'), ('\u0d57', '\u0d57'), ('\u0d62', '\u0d63'),
+ ('\u0d82', '\u0d83'), ('\u0dca', '\u0dca'), ('\u0dcf', '\u0dd4'), ('\u0dd6', '\u0dd6'),
+ ('\u0dd8', '\u0ddf'), ('\u0df2', '\u0df3'), ('\u0e31', '\u0e31'), ('\u0e34', '\u0e3a'),
+ ('\u0e47', '\u0e4e'), ('\u0eb1', '\u0eb1'), ('\u0eb4', '\u0eb9'), ('\u0ebb', '\u0ebc'),
+ ('\u0ec8', '\u0ecd'), ('\u0f18', '\u0f19'), ('\u0f35', '\u0f35'), ('\u0f37', '\u0f37'),
+ ('\u0f39', '\u0f39'), ('\u0f3e', '\u0f3f'), ('\u0f71', '\u0f84'), ('\u0f86', '\u0f87'),
+ ('\u0f8d', '\u0f97'), ('\u0f99', '\u0fbc'), ('\u0fc6', '\u0fc6'), ('\u102b', '\u103e'),
+ ('\u1056', '\u1059'), ('\u105e', '\u1060'), ('\u1062', '\u1064'), ('\u1067', '\u106d'),
+ ('\u1071', '\u1074'), ('\u1082', '\u108d'), ('\u108f', '\u108f'), ('\u109a', '\u109d'),
+ ('\u135d', '\u135f'), ('\u1712', '\u1714'), ('\u1732', '\u1734'), ('\u1752', '\u1753'),
+ ('\u1772', '\u1773'), ('\u17b4', '\u17d3'), ('\u17dd', '\u17dd'), ('\u180b', '\u180d'),
+ ('\u18a9', '\u18a9'), ('\u1920', '\u192b'), ('\u1930', '\u193b'), ('\u19b0', '\u19c0'),
+ ('\u19c8', '\u19c9'), ('\u1a17', '\u1a1b'), ('\u1a55', '\u1a5e'), ('\u1a60', '\u1a7c'),
+ ('\u1a7f', '\u1a7f'), ('\u1ab0', '\u1abe'), ('\u1b00', '\u1b04'), ('\u1b34', '\u1b44'),
+ ('\u1b6b', '\u1b73'), ('\u1b80', '\u1b82'), ('\u1ba1', '\u1bad'), ('\u1be6', '\u1bf3'),
+ ('\u1c24', '\u1c37'), ('\u1cd0', '\u1cd2'), ('\u1cd4', '\u1ce8'), ('\u1ced', '\u1ced'),
+ ('\u1cf2', '\u1cf4'), ('\u1cf8', '\u1cf9'), ('\u1dc0', '\u1df5'), ('\u1dfc', '\u1dff'),
+ ('\u20d0', '\u20f0'), ('\u2cef', '\u2cf1'), ('\u2d7f', '\u2d7f'), ('\u2de0', '\u2dff'),
+ ('\u302a', '\u302f'), ('\u3099', '\u309a'), ('\ua66f', '\ua672'), ('\ua674', '\ua67d'),
+ ('\ua69f', '\ua69f'), ('\ua6f0', '\ua6f1'), ('\ua802', '\ua802'), ('\ua806', '\ua806'),
+ ('\ua80b', '\ua80b'), ('\ua823', '\ua827'), ('\ua880', '\ua881'), ('\ua8b4', '\ua8c4'),
+ ('\ua8e0', '\ua8f1'), ('\ua926', '\ua92d'), ('\ua947', '\ua953'), ('\ua980', '\ua983'),
+ ('\ua9b3', '\ua9c0'), ('\ua9e5', '\ua9e5'), ('\uaa29', '\uaa36'), ('\uaa43', '\uaa43'),
+ ('\uaa4c', '\uaa4d'), ('\uaa7b', '\uaa7d'), ('\uaab0', '\uaab0'), ('\uaab2', '\uaab4'),
+ ('\uaab7', '\uaab8'), ('\uaabe', '\uaabf'), ('\uaac1', '\uaac1'), ('\uaaeb', '\uaaef'),
+ ('\uaaf5', '\uaaf6'), ('\uabe3', '\uabea'), ('\uabec', '\uabed'), ('\ufb1e', '\ufb1e'),
+ ('\ufe00', '\ufe0f'), ('\ufe20', '\ufe2d'), ('\U000101fd', '\U000101fd'), ('\U000102e0',
+ '\U000102e0'), ('\U00010376', '\U0001037a'), ('\U00010a01', '\U00010a03'), ('\U00010a05',
+ '\U00010a06'), ('\U00010a0c', '\U00010a0f'), ('\U00010a38', '\U00010a3a'), ('\U00010a3f',
+ '\U00010a3f'), ('\U00010ae5', '\U00010ae6'), ('\U00011000', '\U00011002'), ('\U00011038',
+ '\U00011046'), ('\U0001107f', '\U00011082'), ('\U000110b0', '\U000110ba'), ('\U00011100',
+ '\U00011102'), ('\U00011127', '\U00011134'), ('\U00011173', '\U00011173'), ('\U00011180',
+ '\U00011182'), ('\U000111b3', '\U000111c0'), ('\U0001122c', '\U00011237'), ('\U000112df',
+ '\U000112ea'), ('\U00011301', '\U00011303'), ('\U0001133c', '\U0001133c'), ('\U0001133e',
+ '\U00011344'), ('\U00011347', '\U00011348'), ('\U0001134b', '\U0001134d'), ('\U00011357',
+ '\U00011357'), ('\U00011362', '\U00011363'), ('\U00011366', '\U0001136c'), ('\U00011370',
+ '\U00011374'), ('\U000114b0', '\U000114c3'), ('\U000115af', '\U000115b5'), ('\U000115b8',
+ '\U000115c0'), ('\U00011630', '\U00011640'), ('\U000116ab', '\U000116b7'), ('\U00016af0',
+ '\U00016af4'), ('\U00016b30', '\U00016b36'), ('\U00016f51', '\U00016f7e'), ('\U00016f8f',
+ '\U00016f92'), ('\U0001bc9d', '\U0001bc9e'), ('\U0001d165', '\U0001d169'), ('\U0001d16d',
+ '\U0001d172'), ('\U0001d17b', '\U0001d182'), ('\U0001d185', '\U0001d18b'), ('\U0001d1aa',
+ '\U0001d1ad'), ('\U0001d242', '\U0001d244'), ('\U0001e8d0', '\U0001e8d6'), ('\U000e0100',
+ '\U000e01ef')
+ ];
+
+ pub static Mc_table: &'static [(char, char)] = &[
+ ('\u0903', '\u0903'), ('\u093b', '\u093b'), ('\u093e', '\u0940'), ('\u0949', '\u094c'),
+ ('\u094e', '\u094f'), ('\u0982', '\u0983'), ('\u09be', '\u09c0'), ('\u09c7', '\u09c8'),
+ ('\u09cb', '\u09cc'), ('\u09d7', '\u09d7'), ('\u0a03', '\u0a03'), ('\u0a3e', '\u0a40'),
+ ('\u0a83', '\u0a83'), ('\u0abe', '\u0ac0'), ('\u0ac9', '\u0ac9'), ('\u0acb', '\u0acc'),
+ ('\u0b02', '\u0b03'), ('\u0b3e', '\u0b3e'), ('\u0b40', '\u0b40'), ('\u0b47', '\u0b48'),
+ ('\u0b4b', '\u0b4c'), ('\u0b57', '\u0b57'), ('\u0bbe', '\u0bbf'), ('\u0bc1', '\u0bc2'),
+ ('\u0bc6', '\u0bc8'), ('\u0bca', '\u0bcc'), ('\u0bd7', '\u0bd7'), ('\u0c01', '\u0c03'),
+ ('\u0c41', '\u0c44'), ('\u0c82', '\u0c83'), ('\u0cbe', '\u0cbe'), ('\u0cc0', '\u0cc4'),
+ ('\u0cc7', '\u0cc8'), ('\u0cca', '\u0ccb'), ('\u0cd5', '\u0cd6'), ('\u0d02', '\u0d03'),
+ ('\u0d3e', '\u0d40'), ('\u0d46', '\u0d48'), ('\u0d4a', '\u0d4c'), ('\u0d57', '\u0d57'),
+ ('\u0d82', '\u0d83'), ('\u0dcf', '\u0dd1'), ('\u0dd8', '\u0ddf'), ('\u0df2', '\u0df3'),
+ ('\u0f3e', '\u0f3f'), ('\u0f7f', '\u0f7f'), ('\u102b', '\u102c'), ('\u1031', '\u1031'),
+ ('\u1038', '\u1038'), ('\u103b', '\u103c'), ('\u1056', '\u1057'), ('\u1062', '\u1064'),
+ ('\u1067', '\u106d'), ('\u1083', '\u1084'), ('\u1087', '\u108c'), ('\u108f', '\u108f'),
+ ('\u109a', '\u109c'), ('\u17b6', '\u17b6'), ('\u17be', '\u17c5'), ('\u17c7', '\u17c8'),
+ ('\u1923', '\u1926'), ('\u1929', '\u192b'), ('\u1930', '\u1931'), ('\u1933', '\u1938'),
+ ('\u19b0', '\u19c0'), ('\u19c8', '\u19c9'), ('\u1a19', '\u1a1a'), ('\u1a55', '\u1a55'),
+ ('\u1a57', '\u1a57'), ('\u1a61', '\u1a61'), ('\u1a63', '\u1a64'), ('\u1a6d', '\u1a72'),
+ ('\u1b04', '\u1b04'), ('\u1b35', '\u1b35'), ('\u1b3b', '\u1b3b'), ('\u1b3d', '\u1b41'),
+ ('\u1b43', '\u1b44'), ('\u1b82', '\u1b82'), ('\u1ba1', '\u1ba1'), ('\u1ba6', '\u1ba7'),
+ ('\u1baa', '\u1baa'), ('\u1be7', '\u1be7'), ('\u1bea', '\u1bec'), ('\u1bee', '\u1bee'),
+ ('\u1bf2', '\u1bf3'), ('\u1c24', '\u1c2b'), ('\u1c34', '\u1c35'), ('\u1ce1', '\u1ce1'),
+ ('\u1cf2', '\u1cf3'), ('\u302e', '\u302f'), ('\ua823', '\ua824'), ('\ua827', '\ua827'),
+ ('\ua880', '\ua881'), ('\ua8b4', '\ua8c3'), ('\ua952', '\ua953'), ('\ua983', '\ua983'),
+ ('\ua9b4', '\ua9b5'), ('\ua9ba', '\ua9bb'), ('\ua9bd', '\ua9c0'), ('\uaa2f', '\uaa30'),
+ ('\uaa33', '\uaa34'), ('\uaa4d', '\uaa4d'), ('\uaa7b', '\uaa7b'), ('\uaa7d', '\uaa7d'),
+ ('\uaaeb', '\uaaeb'), ('\uaaee', '\uaaef'), ('\uaaf5', '\uaaf5'), ('\uabe3', '\uabe4'),
+ ('\uabe6', '\uabe7'), ('\uabe9', '\uabea'), ('\uabec', '\uabec'), ('\U00011000',
+ '\U00011000'), ('\U00011002', '\U00011002'), ('\U00011082', '\U00011082'), ('\U000110b0',
+ '\U000110b2'), ('\U000110b7', '\U000110b8'), ('\U0001112c', '\U0001112c'), ('\U00011182',
+ '\U00011182'), ('\U000111b3', '\U000111b5'), ('\U000111bf', '\U000111c0'), ('\U0001122c',
+ '\U0001122e'), ('\U00011232', '\U00011233'), ('\U00011235', '\U00011235'), ('\U000112e0',
+ '\U000112e2'), ('\U00011302', '\U00011303'), ('\U0001133e', '\U0001133f'), ('\U00011341',
+ '\U00011344'), ('\U00011347', '\U00011348'), ('\U0001134b', '\U0001134d'), ('\U00011357',
+ '\U00011357'), ('\U00011362', '\U00011363'), ('\U000114b0', '\U000114b2'), ('\U000114b9',
+ '\U000114b9'), ('\U000114bb', '\U000114be'), ('\U000114c1', '\U000114c1'), ('\U000115af',
+ '\U000115b1'), ('\U000115b8', '\U000115bb'), ('\U000115be', '\U000115be'), ('\U00011630',
+ '\U00011632'), ('\U0001163b', '\U0001163c'), ('\U0001163e', '\U0001163e'), ('\U000116ac',
+ '\U000116ac'), ('\U000116ae', '\U000116af'), ('\U000116b6', '\U000116b6'), ('\U00016f51',
+ '\U00016f7e'), ('\U0001d165', '\U0001d166'), ('\U0001d16d', '\U0001d172')
+ ];
+
+ pub static Me_table: &'static [(char, char)] = &[
+ ('\u0488', '\u0489'), ('\u1abe', '\u1abe'), ('\u20dd', '\u20e0'), ('\u20e2', '\u20e4'),
+ ('\ua670', '\ua672')
+ ];
+
+ pub static Mn_table: &'static [(char, char)] = &[
+ ('\u0300', '\u036f'), ('\u0483', '\u0487'), ('\u0591', '\u05bd'), ('\u05bf', '\u05bf'),
+ ('\u05c1', '\u05c2'), ('\u05c4', '\u05c5'), ('\u05c7', '\u05c7'), ('\u0610', '\u061a'),
+ ('\u064b', '\u065f'), ('\u0670', '\u0670'), ('\u06d6', '\u06dc'), ('\u06df', '\u06e4'),
+ ('\u06e7', '\u06e8'), ('\u06ea', '\u06ed'), ('\u0711', '\u0711'), ('\u0730', '\u074a'),
+ ('\u07a6', '\u07b0'), ('\u07eb', '\u07f3'), ('\u0816', '\u0819'), ('\u081b', '\u0823'),
+ ('\u0825', '\u0827'), ('\u0829', '\u082d'), ('\u0859', '\u085b'), ('\u08e4', '\u0902'),
+ ('\u093a', '\u093a'), ('\u093c', '\u093c'), ('\u0941', '\u0948'), ('\u094d', '\u094d'),
+ ('\u0951', '\u0957'), ('\u0962', '\u0963'), ('\u0981', '\u0981'), ('\u09bc', '\u09bc'),
+ ('\u09c1', '\u09c4'), ('\u09cd', '\u09cd'), ('\u09e2', '\u09e3'), ('\u0a01', '\u0a02'),
+ ('\u0a3c', '\u0a3c'), ('\u0a41', '\u0a42'), ('\u0a47', '\u0a48'), ('\u0a4b', '\u0a4d'),
+ ('\u0a51', '\u0a51'), ('\u0a70', '\u0a71'), ('\u0a75', '\u0a75'), ('\u0a81', '\u0a82'),
+ ('\u0abc', '\u0abc'), ('\u0ac1', '\u0ac5'), ('\u0ac7', '\u0ac8'), ('\u0acd', '\u0acd'),
+ ('\u0ae2', '\u0ae3'), ('\u0b01', '\u0b01'), ('\u0b3c', '\u0b3c'), ('\u0b3f', '\u0b3f'),
+ ('\u0b41', '\u0b44'), ('\u0b4d', '\u0b4d'), ('\u0b56', '\u0b56'), ('\u0b62', '\u0b63'),
+ ('\u0b82', '\u0b82'), ('\u0bc0', '\u0bc0'), ('\u0bcd', '\u0bcd'), ('\u0c00', '\u0c00'),
+ ('\u0c3e', '\u0c40'), ('\u0c46', '\u0c48'), ('\u0c4a', '\u0c4d'), ('\u0c55', '\u0c56'),
+ ('\u0c62', '\u0c63'), ('\u0c81', '\u0c81'), ('\u0cbc', '\u0cbc'), ('\u0cbf', '\u0cbf'),
+ ('\u0cc6', '\u0cc6'), ('\u0ccc', '\u0ccd'), ('\u0ce2', '\u0ce3'), ('\u0d01', '\u0d01'),
+ ('\u0d41', '\u0d44'), ('\u0d4d', '\u0d4d'), ('\u0d62', '\u0d63'), ('\u0dca', '\u0dca'),
+ ('\u0dd2', '\u0dd4'), ('\u0dd6', '\u0dd6'), ('\u0e31', '\u0e31'), ('\u0e34', '\u0e3a'),
+ ('\u0e47', '\u0e4e'), ('\u0eb1', '\u0eb1'), ('\u0eb4', '\u0eb9'), ('\u0ebb', '\u0ebc'),
+ ('\u0ec8', '\u0ecd'), ('\u0f18', '\u0f19'), ('\u0f35', '\u0f35'), ('\u0f37', '\u0f37'),
+ ('\u0f39', '\u0f39'), ('\u0f71', '\u0f7e'), ('\u0f80', '\u0f84'), ('\u0f86', '\u0f87'),
+ ('\u0f8d', '\u0f97'), ('\u0f99', '\u0fbc'), ('\u0fc6', '\u0fc6'), ('\u102d', '\u1030'),
+ ('\u1032', '\u1037'), ('\u1039', '\u103a'), ('\u103d', '\u103e'), ('\u1058', '\u1059'),
+ ('\u105e', '\u1060'), ('\u1071', '\u1074'), ('\u1082', '\u1082'), ('\u1085', '\u1086'),
+ ('\u108d', '\u108d'), ('\u109d', '\u109d'), ('\u135d', '\u135f'), ('\u1712', '\u1714'),
+ ('\u1732', '\u1734'), ('\u1752', '\u1753'), ('\u1772', '\u1773'), ('\u17b4', '\u17b5'),
+ ('\u17b7', '\u17bd'), ('\u17c6', '\u17c6'), ('\u17c9', '\u17d3'), ('\u17dd', '\u17dd'),
+ ('\u180b', '\u180d'), ('\u18a9', '\u18a9'), ('\u1920', '\u1922'), ('\u1927', '\u1928'),
+ ('\u1932', '\u1932'), ('\u1939', '\u193b'), ('\u1a17', '\u1a18'), ('\u1a1b', '\u1a1b'),
+ ('\u1a56', '\u1a56'), ('\u1a58', '\u1a5e'), ('\u1a60', '\u1a60'), ('\u1a62', '\u1a62'),
+ ('\u1a65', '\u1a6c'), ('\u1a73', '\u1a7c'), ('\u1a7f', '\u1a7f'), ('\u1ab0', '\u1abd'),
+ ('\u1b00', '\u1b03'), ('\u1b34', '\u1b34'), ('\u1b36', '\u1b3a'), ('\u1b3c', '\u1b3c'),
+ ('\u1b42', '\u1b42'), ('\u1b6b', '\u1b73'), ('\u1b80', '\u1b81'), ('\u1ba2', '\u1ba5'),
+ ('\u1ba8', '\u1ba9'), ('\u1bab', '\u1bad'), ('\u1be6', '\u1be6'), ('\u1be8', '\u1be9'),
+ ('\u1bed', '\u1bed'), ('\u1bef', '\u1bf1'), ('\u1c2c', '\u1c33'), ('\u1c36', '\u1c37'),
+ ('\u1cd0', '\u1cd2'), ('\u1cd4', '\u1ce0'), ('\u1ce2', '\u1ce8'), ('\u1ced', '\u1ced'),
+ ('\u1cf4', '\u1cf4'), ('\u1cf8', '\u1cf9'), ('\u1dc0', '\u1df5'), ('\u1dfc', '\u1dff'),
+ ('\u20d0', '\u20dc'), ('\u20e1', '\u20e1'), ('\u20e5', '\u20f0'), ('\u2cef', '\u2cf1'),
+ ('\u2d7f', '\u2d7f'), ('\u2de0', '\u2dff'), ('\u302a', '\u302d'), ('\u3099', '\u309a'),
+ ('\ua66f', '\ua66f'), ('\ua674', '\ua67d'), ('\ua69f', '\ua69f'), ('\ua6f0', '\ua6f1'),
+ ('\ua802', '\ua802'), ('\ua806', '\ua806'), ('\ua80b', '\ua80b'), ('\ua825', '\ua826'),
+ ('\ua8c4', '\ua8c4'), ('\ua8e0', '\ua8f1'), ('\ua926', '\ua92d'), ('\ua947', '\ua951'),
+ ('\ua980', '\ua982'), ('\ua9b3', '\ua9b3'), ('\ua9b6', '\ua9b9'), ('\ua9bc', '\ua9bc'),
+ ('\ua9e5', '\ua9e5'), ('\uaa29', '\uaa2e'), ('\uaa31', '\uaa32'), ('\uaa35', '\uaa36'),
+ ('\uaa43', '\uaa43'), ('\uaa4c', '\uaa4c'), ('\uaa7c', '\uaa7c'), ('\uaab0', '\uaab0'),
+ ('\uaab2', '\uaab4'), ('\uaab7', '\uaab8'), ('\uaabe', '\uaabf'), ('\uaac1', '\uaac1'),
+ ('\uaaec', '\uaaed'), ('\uaaf6', '\uaaf6'), ('\uabe5', '\uabe5'), ('\uabe8', '\uabe8'),
+ ('\uabed', '\uabed'), ('\ufb1e', '\ufb1e'), ('\ufe00', '\ufe0f'), ('\ufe20', '\ufe2d'),
+ ('\U000101fd', '\U000101fd'), ('\U000102e0', '\U000102e0'), ('\U00010376', '\U0001037a'),
+ ('\U00010a01', '\U00010a03'), ('\U00010a05', '\U00010a06'), ('\U00010a0c', '\U00010a0f'),
+ ('\U00010a38', '\U00010a3a'), ('\U00010a3f', '\U00010a3f'), ('\U00010ae5', '\U00010ae6'),
+ ('\U00011001', '\U00011001'), ('\U00011038', '\U00011046'), ('\U0001107f', '\U00011081'),
+ ('\U000110b3', '\U000110b6'), ('\U000110b9', '\U000110ba'), ('\U00011100', '\U00011102'),
+ ('\U00011127', '\U0001112b'), ('\U0001112d', '\U00011134'), ('\U00011173', '\U00011173'),
+ ('\U00011180', '\U00011181'), ('\U000111b6', '\U000111be'), ('\U0001122f', '\U00011231'),
+ ('\U00011234', '\U00011234'), ('\U00011236', '\U00011237'), ('\U000112df', '\U000112df'),
+ ('\U000112e3', '\U000112ea'), ('\U00011301', '\U00011301'), ('\U0001133c', '\U0001133c'),
+ ('\U00011340', '\U00011340'), ('\U00011366', '\U0001136c'), ('\U00011370', '\U00011374'),
+ ('\U000114b3', '\U000114b8'), ('\U000114ba', '\U000114ba'), ('\U000114bf', '\U000114c0'),
+ ('\U000114c2', '\U000114c3'), ('\U000115b2', '\U000115b5'), ('\U000115bc', '\U000115bd'),
+ ('\U000115bf', '\U000115c0'), ('\U00011633', '\U0001163a'), ('\U0001163d', '\U0001163d'),
+ ('\U0001163f', '\U00011640'), ('\U000116ab', '\U000116ab'), ('\U000116ad', '\U000116ad'),
+ ('\U000116b0', '\U000116b5'), ('\U000116b7', '\U000116b7'), ('\U00016af0', '\U00016af4'),
+ ('\U00016b30', '\U00016b36'), ('\U00016f8f', '\U00016f92'), ('\U0001bc9d', '\U0001bc9e'),
+ ('\U0001d167', '\U0001d169'), ('\U0001d17b', '\U0001d182'), ('\U0001d185', '\U0001d18b'),
+ ('\U0001d1aa', '\U0001d1ad'), ('\U0001d242', '\U0001d244'), ('\U0001e8d0', '\U0001e8d6'),
+ ('\U000e0100', '\U000e01ef')
+ ];
+
+ pub static N_table: &'static [(char, char)] = &[
+ ('\x30', '\x39'), ('\u0660', '\u0669'), ('\u06f0', '\u06f9'), ('\u07c0', '\u07c9'),
+ ('\u0966', '\u096f'), ('\u09e6', '\u09ef'), ('\u0a66', '\u0a6f'), ('\u0ae6', '\u0aef'),
+ ('\u0b66', '\u0b6f'), ('\u0be6', '\u0bef'), ('\u0c66', '\u0c6f'), ('\u0ce6', '\u0cef'),
+ ('\u0d66', '\u0d6f'), ('\u0de6', '\u0def'), ('\u0e50', '\u0e59'), ('\u0ed0', '\u0ed9'),
+ ('\u0f20', '\u0f29'), ('\u1040', '\u1049'), ('\u1090', '\u1099'), ('\u16ee', '\u16f0'),
+ ('\u17e0', '\u17e9'), ('\u1810', '\u1819'), ('\u1946', '\u194f'), ('\u19d0', '\u19d9'),
+ ('\u1a80', '\u1a89'), ('\u1a90', '\u1a99'), ('\u1b50', '\u1b59'), ('\u1bb0', '\u1bb9'),
+ ('\u1c40', '\u1c49'), ('\u1c50', '\u1c59'), ('\u2160', '\u2182'), ('\u2185', '\u2188'),
+ ('\u3007', '\u3007'), ('\u3021', '\u3029'), ('\u3038', '\u303a'), ('\ua620', '\ua629'),
+ ('\ua6e6', '\ua6ef'), ('\ua8d0', '\ua8d9'), ('\ua900', '\ua909'), ('\ua9d0', '\ua9d9'),
+ ('\ua9f0', '\ua9f9'), ('\uaa50', '\uaa59'), ('\uabf0', '\uabf9'), ('\uff10', '\uff19'),
+ ('\U00010140', '\U00010174'), ('\U00010341', '\U00010341'), ('\U0001034a', '\U0001034a'),
+ ('\U000103d1', '\U000103d5'), ('\U000104a0', '\U000104a9'), ('\U00011066', '\U0001106f'),
+ ('\U000110f0', '\U000110f9'), ('\U00011136', '\U0001113f'), ('\U000111d0', '\U000111d9'),
+ ('\U000112f0', '\U000112f9'), ('\U000114d0', '\U000114d9'), ('\U00011650', '\U00011659'),
+ ('\U000116c0', '\U000116c9'), ('\U000118e0', '\U000118e9'), ('\U00012400', '\U0001246e'),
+ ('\U00016a60', '\U00016a69'), ('\U00016b50', '\U00016b59'), ('\U0001d7ce', '\U0001d7ff')
+ ];
+
+ pub fn N(c: char) -> bool {
+ super::bsearch_range_table(c, N_table)
+ }
+
+ pub static Nd_table: &'static [(char, char)] = &[
+ ('\x30', '\x39'), ('\u0660', '\u0669'), ('\u06f0', '\u06f9'), ('\u07c0', '\u07c9'),
+ ('\u0966', '\u096f'), ('\u09e6', '\u09ef'), ('\u0a66', '\u0a6f'), ('\u0ae6', '\u0aef'),
+ ('\u0b66', '\u0b6f'), ('\u0be6', '\u0bef'), ('\u0c66', '\u0c6f'), ('\u0ce6', '\u0cef'),
+ ('\u0d66', '\u0d6f'), ('\u0de6', '\u0def'), ('\u0e50', '\u0e59'), ('\u0ed0', '\u0ed9'),
+ ('\u0f20', '\u0f29'), ('\u1040', '\u1049'), ('\u1090', '\u1099'), ('\u17e0', '\u17e9'),
+ ('\u1810', '\u1819'), ('\u1946', '\u194f'), ('\u19d0', '\u19d9'), ('\u1a80', '\u1a89'),
+ ('\u1a90', '\u1a99'), ('\u1b50', '\u1b59'), ('\u1bb0', '\u1bb9'), ('\u1c40', '\u1c49'),
+ ('\u1c50', '\u1c59'), ('\ua620', '\ua629'), ('\ua8d0', '\ua8d9'), ('\ua900', '\ua909'),
+ ('\ua9d0', '\ua9d9'), ('\ua9f0', '\ua9f9'), ('\uaa50', '\uaa59'), ('\uabf0', '\uabf9'),
+ ('\uff10', '\uff19'), ('\U000104a0', '\U000104a9'), ('\U00011066', '\U0001106f'),
+ ('\U000110f0', '\U000110f9'), ('\U00011136', '\U0001113f'), ('\U000111d0', '\U000111d9'),
+ ('\U000112f0', '\U000112f9'), ('\U000114d0', '\U000114d9'), ('\U00011650', '\U00011659'),
+ ('\U000116c0', '\U000116c9'), ('\U000118e0', '\U000118e9'), ('\U00016a60', '\U00016a69'),
+ ('\U00016b50', '\U00016b59'), ('\U0001d7ce', '\U0001d7ff')
+ ];
+
+ pub static Nl_table: &'static [(char, char)] = &[
+ ('\u16ee', '\u16f0'), ('\u2160', '\u2182'), ('\u2185', '\u2188'), ('\u3007', '\u3007'),
+ ('\u3021', '\u3029'), ('\u3038', '\u303a'), ('\ua6e6', '\ua6ef'), ('\U00010140',
+ '\U00010174'), ('\U00010341', '\U00010341'), ('\U0001034a', '\U0001034a'), ('\U000103d1',
+ '\U000103d5'), ('\U00012400', '\U0001246e')
+ ];
+
+ pub static No_table: &'static [(char, char)] = &[
+ ('\xb2', '\xb3'), ('\xb9', '\xb9'), ('\xbc', '\xbe'), ('\u09f4', '\u09f9'), ('\u0b72',
+ '\u0b77'), ('\u0bf0', '\u0bf2'), ('\u0c78', '\u0c7e'), ('\u0d70', '\u0d75'), ('\u0f2a',
+ '\u0f33'), ('\u1369', '\u137c'), ('\u17f0', '\u17f9'), ('\u19da', '\u19da'), ('\u2070',
+ '\u2070'), ('\u2074', '\u2079'), ('\u2080', '\u2089'), ('\u2150', '\u215f'), ('\u2189',
+ '\u2189'), ('\u2460', '\u249b'), ('\u24ea', '\u24ff'), ('\u2776', '\u2793'), ('\u2cfd',
+ '\u2cfd'), ('\u3192', '\u3195'), ('\u3220', '\u3229'), ('\u3248', '\u324f'), ('\u3251',
+ '\u325f'), ('\u3280', '\u3289'), ('\u32b1', '\u32bf'), ('\ua830', '\ua835'), ('\U00010107',
+ '\U00010133'), ('\U00010175', '\U00010178'), ('\U0001018a', '\U0001018b'), ('\U000102e1',
+ '\U000102fb'), ('\U00010320', '\U00010323'), ('\U00010858', '\U0001085f'), ('\U00010879',
+ '\U0001087f'), ('\U000108a7', '\U000108af'), ('\U00010916', '\U0001091b'), ('\U00010a40',
+ '\U00010a47'), ('\U00010a7d', '\U00010a7e'), ('\U00010a9d', '\U00010a9f'), ('\U00010aeb',
+ '\U00010aef'), ('\U00010b58', '\U00010b5f'), ('\U00010b78', '\U00010b7f'), ('\U00010ba9',
+ '\U00010baf'), ('\U00010e60', '\U00010e7e'), ('\U00011052', '\U00011065'), ('\U000111e1',
+ '\U000111f4'), ('\U000118ea', '\U000118f2'), ('\U00016b5b', '\U00016b61'), ('\U0001d360',
+ '\U0001d371'), ('\U0001e8c7', '\U0001e8cf'), ('\U0001f100', '\U0001f10c')
+ ];
+
+ pub static P_table: &'static [(char, char)] = &[
+ ('\x21', '\x23'), ('\x25', '\x2a'), ('\x2c', '\x2f'), ('\x3a', '\x3b'), ('\x3f', '\x40'),
+ ('\x5b', '\x5d'), ('\x5f', '\x5f'), ('\x7b', '\x7b'), ('\x7d', '\x7d'), ('\xa1', '\xa1'),
+ ('\xa7', '\xa7'), ('\xab', '\xab'), ('\xb6', '\xb7'), ('\xbb', '\xbb'), ('\xbf', '\xbf'),
+ ('\u037e', '\u037e'), ('\u0387', '\u0387'), ('\u055a', '\u055f'), ('\u0589', '\u058a'),
+ ('\u05be', '\u05be'), ('\u05c0', '\u05c0'), ('\u05c3', '\u05c3'), ('\u05c6', '\u05c6'),
+ ('\u05f3', '\u05f4'), ('\u0609', '\u060a'), ('\u060c', '\u060d'), ('\u061b', '\u061b'),
+ ('\u061e', '\u061f'), ('\u066a', '\u066d'), ('\u06d4', '\u06d4'), ('\u0700', '\u070d'),
+ ('\u07f7', '\u07f9'), ('\u0830', '\u083e'), ('\u085e', '\u085e'), ('\u0964', '\u0965'),
+ ('\u0970', '\u0970'), ('\u0af0', '\u0af0'), ('\u0df4', '\u0df4'), ('\u0e4f', '\u0e4f'),
+ ('\u0e5a', '\u0e5b'), ('\u0f04', '\u0f12'), ('\u0f14', '\u0f14'), ('\u0f3a', '\u0f3d'),
+ ('\u0f85', '\u0f85'), ('\u0fd0', '\u0fd4'), ('\u0fd9', '\u0fda'), ('\u104a', '\u104f'),
+ ('\u10fb', '\u10fb'), ('\u1360', '\u1368'), ('\u1400', '\u1400'), ('\u166d', '\u166e'),
+ ('\u169b', '\u169c'), ('\u16eb', '\u16ed'), ('\u1735', '\u1736'), ('\u17d4', '\u17d6'),
+ ('\u17d8', '\u17da'), ('\u1800', '\u180a'), ('\u1944', '\u1945'), ('\u1a1e', '\u1a1f'),
+ ('\u1aa0', '\u1aa6'), ('\u1aa8', '\u1aad'), ('\u1b5a', '\u1b60'), ('\u1bfc', '\u1bff'),
+ ('\u1c3b', '\u1c3f'), ('\u1c7e', '\u1c7f'), ('\u1cc0', '\u1cc7'), ('\u1cd3', '\u1cd3'),
+ ('\u2010', '\u2027'), ('\u2030', '\u2043'), ('\u2045', '\u2051'), ('\u2053', '\u205e'),
+ ('\u207d', '\u207e'), ('\u208d', '\u208e'), ('\u2308', '\u230b'), ('\u2329', '\u232a'),
+ ('\u2768', '\u2775'), ('\u27c5', '\u27c6'), ('\u27e6', '\u27ef'), ('\u2983', '\u2998'),
+ ('\u29d8', '\u29db'), ('\u29fc', '\u29fd'), ('\u2cf9', '\u2cfc'), ('\u2cfe', '\u2cff'),
+ ('\u2d70', '\u2d70'), ('\u2e00', '\u2e2e'), ('\u2e30', '\u2e42'), ('\u3001', '\u3003'),
+ ('\u3008', '\u3011'), ('\u3014', '\u301f'), ('\u3030', '\u3030'), ('\u303d', '\u303d'),
+ ('\u30a0', '\u30a0'), ('\u30fb', '\u30fb'), ('\ua4fe', '\ua4ff'), ('\ua60d', '\ua60f'),
+ ('\ua673', '\ua673'), ('\ua67e', '\ua67e'), ('\ua6f2', '\ua6f7'), ('\ua874', '\ua877'),
+ ('\ua8ce', '\ua8cf'), ('\ua8f8', '\ua8fa'), ('\ua92e', '\ua92f'), ('\ua95f', '\ua95f'),
+ ('\ua9c1', '\ua9cd'), ('\ua9de', '\ua9df'), ('\uaa5c', '\uaa5f'), ('\uaade', '\uaadf'),
+ ('\uaaf0', '\uaaf1'), ('\uabeb', '\uabeb'), ('\ufd3e', '\ufd3f'), ('\ufe10', '\ufe19'),
+ ('\ufe30', '\ufe52'), ('\ufe54', '\ufe61'), ('\ufe63', '\ufe63'), ('\ufe68', '\ufe68'),
+ ('\ufe6a', '\ufe6b'), ('\uff01', '\uff03'), ('\uff05', '\uff0a'), ('\uff0c', '\uff0f'),
+ ('\uff1a', '\uff1b'), ('\uff1f', '\uff20'), ('\uff3b', '\uff3d'), ('\uff3f', '\uff3f'),
+ ('\uff5b', '\uff5b'), ('\uff5d', '\uff5d'), ('\uff5f', '\uff65'), ('\U00010100',
+ '\U00010102'), ('\U0001039f', '\U0001039f'), ('\U000103d0', '\U000103d0'), ('\U0001056f',
+ '\U0001056f'), ('\U00010857', '\U00010857'), ('\U0001091f', '\U0001091f'), ('\U0001093f',
+ '\U0001093f'), ('\U00010a50', '\U00010a58'), ('\U00010a7f', '\U00010a7f'), ('\U00010af0',
+ '\U00010af6'), ('\U00010b39', '\U00010b3f'), ('\U00010b99', '\U00010b9c'), ('\U00011047',
+ '\U0001104d'), ('\U000110bb', '\U000110bc'), ('\U000110be', '\U000110c1'), ('\U00011140',
+ '\U00011143'), ('\U00011174', '\U00011175'), ('\U000111c5', '\U000111c8'), ('\U000111cd',
+ '\U000111cd'), ('\U00011238', '\U0001123d'), ('\U000114c6', '\U000114c6'), ('\U000115c1',
+ '\U000115c9'), ('\U00011641', '\U00011643'), ('\U00012470', '\U00012474'), ('\U00016a6e',
+ '\U00016a6f'), ('\U00016af5', '\U00016af5'), ('\U00016b37', '\U00016b3b'), ('\U00016b44',
+ '\U00016b44'), ('\U0001bc9f', '\U0001bc9f')
+ ];
+
+ pub static Pc_table: &'static [(char, char)] = &[
+ ('\x5f', '\x5f'), ('\u203f', '\u2040'), ('\u2054', '\u2054'), ('\ufe33', '\ufe34'),
+ ('\ufe4d', '\ufe4f'), ('\uff3f', '\uff3f')
+ ];
+
+ pub static Pd_table: &'static [(char, char)] = &[
+ ('\x2d', '\x2d'), ('\u058a', '\u058a'), ('\u05be', '\u05be'), ('\u1400', '\u1400'),
+ ('\u1806', '\u1806'), ('\u2010', '\u2015'), ('\u2e17', '\u2e17'), ('\u2e1a', '\u2e1a'),
+ ('\u2e3a', '\u2e3b'), ('\u2e40', '\u2e40'), ('\u301c', '\u301c'), ('\u3030', '\u3030'),
+ ('\u30a0', '\u30a0'), ('\ufe31', '\ufe32'), ('\ufe58', '\ufe58'), ('\ufe63', '\ufe63'),
+ ('\uff0d', '\uff0d')
+ ];
+
+ pub static Pe_table: &'static [(char, char)] = &[
+ ('\x29', '\x29'), ('\x5d', '\x5d'), ('\x7d', '\x7d'), ('\u0f3b', '\u0f3b'), ('\u0f3d',
+ '\u0f3d'), ('\u169c', '\u169c'), ('\u2046', '\u2046'), ('\u207e', '\u207e'), ('\u208e',
+ '\u208e'), ('\u2309', '\u2309'), ('\u230b', '\u230b'), ('\u232a', '\u232a'), ('\u2769',
+ '\u2769'), ('\u276b', '\u276b'), ('\u276d', '\u276d'), ('\u276f', '\u276f'), ('\u2771',
+ '\u2771'), ('\u2773', '\u2773'), ('\u2775', '\u2775'), ('\u27c6', '\u27c6'), ('\u27e7',
+ '\u27e7'), ('\u27e9', '\u27e9'), ('\u27eb', '\u27eb'), ('\u27ed', '\u27ed'), ('\u27ef',
+ '\u27ef'), ('\u2984', '\u2984'), ('\u2986', '\u2986'), ('\u2988', '\u2988'), ('\u298a',
+ '\u298a'), ('\u298c', '\u298c'), ('\u298e', '\u298e'), ('\u2990', '\u2990'), ('\u2992',
+ '\u2992'), ('\u2994', '\u2994'), ('\u2996', '\u2996'), ('\u2998', '\u2998'), ('\u29d9',
+ '\u29d9'), ('\u29db', '\u29db'), ('\u29fd', '\u29fd'), ('\u2e23', '\u2e23'), ('\u2e25',
+ '\u2e25'), ('\u2e27', '\u2e27'), ('\u2e29', '\u2e29'), ('\u3009', '\u3009'), ('\u300b',
+ '\u300b'), ('\u300d', '\u300d'), ('\u300f', '\u300f'), ('\u3011', '\u3011'), ('\u3015',
+ '\u3015'), ('\u3017', '\u3017'), ('\u3019', '\u3019'), ('\u301b', '\u301b'), ('\u301e',
+ '\u301f'), ('\ufd3e', '\ufd3e'), ('\ufe18', '\ufe18'), ('\ufe36', '\ufe36'), ('\ufe38',
+ '\ufe38'), ('\ufe3a', '\ufe3a'), ('\ufe3c', '\ufe3c'), ('\ufe3e', '\ufe3e'), ('\ufe40',
+ '\ufe40'), ('\ufe42', '\ufe42'), ('\ufe44', '\ufe44'), ('\ufe48', '\ufe48'), ('\ufe5a',
+ '\ufe5a'), ('\ufe5c', '\ufe5c'), ('\ufe5e', '\ufe5e'), ('\uff09', '\uff09'), ('\uff3d',
+ '\uff3d'), ('\uff5d', '\uff5d'), ('\uff60', '\uff60'), ('\uff63', '\uff63')
+ ];
+
+ pub static Pf_table: &'static [(char, char)] = &[
+ ('\xbb', '\xbb'), ('\u2019', '\u2019'), ('\u201d', '\u201d'), ('\u203a', '\u203a'),
+ ('\u2e03', '\u2e03'), ('\u2e05', '\u2e05'), ('\u2e0a', '\u2e0a'), ('\u2e0d', '\u2e0d'),
+ ('\u2e1d', '\u2e1d'), ('\u2e21', '\u2e21')
+ ];
+
+ pub static Pi_table: &'static [(char, char)] = &[
+ ('\xab', '\xab'), ('\u2018', '\u2018'), ('\u201b', '\u201c'), ('\u201f', '\u201f'),
+ ('\u2039', '\u2039'), ('\u2e02', '\u2e02'), ('\u2e04', '\u2e04'), ('\u2e09', '\u2e09'),
+ ('\u2e0c', '\u2e0c'), ('\u2e1c', '\u2e1c'), ('\u2e20', '\u2e20')
+ ];
+
+ pub static Po_table: &'static [(char, char)] = &[
+ ('\x21', '\x23'), ('\x25', '\x27'), ('\x2a', '\x2a'), ('\x2c', '\x2c'), ('\x2e', '\x2f'),
+ ('\x3a', '\x3b'), ('\x3f', '\x40'), ('\x5c', '\x5c'), ('\xa1', '\xa1'), ('\xa7', '\xa7'),
+ ('\xb6', '\xb7'), ('\xbf', '\xbf'), ('\u037e', '\u037e'), ('\u0387', '\u0387'), ('\u055a',
+ '\u055f'), ('\u0589', '\u0589'), ('\u05c0', '\u05c0'), ('\u05c3', '\u05c3'), ('\u05c6',
+ '\u05c6'), ('\u05f3', '\u05f4'), ('\u0609', '\u060a'), ('\u060c', '\u060d'), ('\u061b',
+ '\u061b'), ('\u061e', '\u061f'), ('\u066a', '\u066d'), ('\u06d4', '\u06d4'), ('\u0700',
+ '\u070d'), ('\u07f7', '\u07f9'), ('\u0830', '\u083e'), ('\u085e', '\u085e'), ('\u0964',
+ '\u0965'), ('\u0970', '\u0970'), ('\u0af0', '\u0af0'), ('\u0df4', '\u0df4'), ('\u0e4f',
+ '\u0e4f'), ('\u0e5a', '\u0e5b'), ('\u0f04', '\u0f12'), ('\u0f14', '\u0f14'), ('\u0f85',
+ '\u0f85'), ('\u0fd0', '\u0fd4'), ('\u0fd9', '\u0fda'), ('\u104a', '\u104f'), ('\u10fb',
+ '\u10fb'), ('\u1360', '\u1368'), ('\u166d', '\u166e'), ('\u16eb', '\u16ed'), ('\u1735',
+ '\u1736'), ('\u17d4', '\u17d6'), ('\u17d8', '\u17da'), ('\u1800', '\u1805'), ('\u1807',
+ '\u180a'), ('\u1944', '\u1945'), ('\u1a1e', '\u1a1f'), ('\u1aa0', '\u1aa6'), ('\u1aa8',
+ '\u1aad'), ('\u1b5a', '\u1b60'), ('\u1bfc', '\u1bff'), ('\u1c3b', '\u1c3f'), ('\u1c7e',
+ '\u1c7f'), ('\u1cc0', '\u1cc7'), ('\u1cd3', '\u1cd3'), ('\u2016', '\u2017'), ('\u2020',
+ '\u2027'), ('\u2030', '\u2038'), ('\u203b', '\u203e'), ('\u2041', '\u2043'), ('\u2047',
+ '\u2051'), ('\u2053', '\u2053'), ('\u2055', '\u205e'), ('\u2cf9', '\u2cfc'), ('\u2cfe',
+ '\u2cff'), ('\u2d70', '\u2d70'), ('\u2e00', '\u2e01'), ('\u2e06', '\u2e08'), ('\u2e0b',
+ '\u2e0b'), ('\u2e0e', '\u2e16'), ('\u2e18', '\u2e19'), ('\u2e1b', '\u2e1b'), ('\u2e1e',
+ '\u2e1f'), ('\u2e2a', '\u2e2e'), ('\u2e30', '\u2e39'), ('\u2e3c', '\u2e3f'), ('\u2e41',
+ '\u2e41'), ('\u3001', '\u3003'), ('\u303d', '\u303d'), ('\u30fb', '\u30fb'), ('\ua4fe',
+ '\ua4ff'), ('\ua60d', '\ua60f'), ('\ua673', '\ua673'), ('\ua67e', '\ua67e'), ('\ua6f2',
+ '\ua6f7'), ('\ua874', '\ua877'), ('\ua8ce', '\ua8cf'), ('\ua8f8', '\ua8fa'), ('\ua92e',
+ '\ua92f'), ('\ua95f', '\ua95f'), ('\ua9c1', '\ua9cd'), ('\ua9de', '\ua9df'), ('\uaa5c',
+ '\uaa5f'), ('\uaade', '\uaadf'), ('\uaaf0', '\uaaf1'), ('\uabeb', '\uabeb'), ('\ufe10',
+ '\ufe16'), ('\ufe19', '\ufe19'), ('\ufe30', '\ufe30'), ('\ufe45', '\ufe46'), ('\ufe49',
+ '\ufe4c'), ('\ufe50', '\ufe52'), ('\ufe54', '\ufe57'), ('\ufe5f', '\ufe61'), ('\ufe68',
+ '\ufe68'), ('\ufe6a', '\ufe6b'), ('\uff01', '\uff03'), ('\uff05', '\uff07'), ('\uff0a',
+ '\uff0a'), ('\uff0c', '\uff0c'), ('\uff0e', '\uff0f'), ('\uff1a', '\uff1b'), ('\uff1f',
+ '\uff20'), ('\uff3c', '\uff3c'), ('\uff61', '\uff61'), ('\uff64', '\uff65'), ('\U00010100',
+ '\U00010102'), ('\U0001039f', '\U0001039f'), ('\U000103d0', '\U000103d0'), ('\U0001056f',
+ '\U0001056f'), ('\U00010857', '\U00010857'), ('\U0001091f', '\U0001091f'), ('\U0001093f',
+ '\U0001093f'), ('\U00010a50', '\U00010a58'), ('\U00010a7f', '\U00010a7f'), ('\U00010af0',
+ '\U00010af6'), ('\U00010b39', '\U00010b3f'), ('\U00010b99', '\U00010b9c'), ('\U00011047',
+ '\U0001104d'), ('\U000110bb', '\U000110bc'), ('\U000110be', '\U000110c1'), ('\U00011140',
+ '\U00011143'), ('\U00011174', '\U00011175'), ('\U000111c5', '\U000111c8'), ('\U000111cd',
+ '\U000111cd'), ('\U00011238', '\U0001123d'), ('\U000114c6', '\U000114c6'), ('\U000115c1',
+ '\U000115c9'), ('\U00011641', '\U00011643'), ('\U00012470', '\U00012474'), ('\U00016a6e',
+ '\U00016a6f'), ('\U00016af5', '\U00016af5'), ('\U00016b37', '\U00016b3b'), ('\U00016b44',
+ '\U00016b44'), ('\U0001bc9f', '\U0001bc9f')
+ ];
+
+ pub static Ps_table: &'static [(char, char)] = &[
+ ('\x28', '\x28'), ('\x5b', '\x5b'), ('\x7b', '\x7b'), ('\u0f3a', '\u0f3a'), ('\u0f3c',
+ '\u0f3c'), ('\u169b', '\u169b'), ('\u201a', '\u201a'), ('\u201e', '\u201e'), ('\u2045',
+ '\u2045'), ('\u207d', '\u207d'), ('\u208d', '\u208d'), ('\u2308', '\u2308'), ('\u230a',
+ '\u230a'), ('\u2329', '\u2329'), ('\u2768', '\u2768'), ('\u276a', '\u276a'), ('\u276c',
+ '\u276c'), ('\u276e', '\u276e'), ('\u2770', '\u2770'), ('\u2772', '\u2772'), ('\u2774',
+ '\u2774'), ('\u27c5', '\u27c5'), ('\u27e6', '\u27e6'), ('\u27e8', '\u27e8'), ('\u27ea',
+ '\u27ea'), ('\u27ec', '\u27ec'), ('\u27ee', '\u27ee'), ('\u2983', '\u2983'), ('\u2985',
+ '\u2985'), ('\u2987', '\u2987'), ('\u2989', '\u2989'), ('\u298b', '\u298b'), ('\u298d',
+ '\u298d'), ('\u298f', '\u298f'), ('\u2991', '\u2991'), ('\u2993', '\u2993'), ('\u2995',
+ '\u2995'), ('\u2997', '\u2997'), ('\u29d8', '\u29d8'), ('\u29da', '\u29da'), ('\u29fc',
+ '\u29fc'), ('\u2e22', '\u2e22'), ('\u2e24', '\u2e24'), ('\u2e26', '\u2e26'), ('\u2e28',
+ '\u2e28'), ('\u2e42', '\u2e42'), ('\u3008', '\u3008'), ('\u300a', '\u300a'), ('\u300c',
+ '\u300c'), ('\u300e', '\u300e'), ('\u3010', '\u3010'), ('\u3014', '\u3014'), ('\u3016',
+ '\u3016'), ('\u3018', '\u3018'), ('\u301a', '\u301a'), ('\u301d', '\u301d'), ('\ufd3f',
+ '\ufd3f'), ('\ufe17', '\ufe17'), ('\ufe35', '\ufe35'), ('\ufe37', '\ufe37'), ('\ufe39',
+ '\ufe39'), ('\ufe3b', '\ufe3b'), ('\ufe3d', '\ufe3d'), ('\ufe3f', '\ufe3f'), ('\ufe41',
+ '\ufe41'), ('\ufe43', '\ufe43'), ('\ufe47', '\ufe47'), ('\ufe59', '\ufe59'), ('\ufe5b',
+ '\ufe5b'), ('\ufe5d', '\ufe5d'), ('\uff08', '\uff08'), ('\uff3b', '\uff3b'), ('\uff5b',
+ '\uff5b'), ('\uff5f', '\uff5f'), ('\uff62', '\uff62')
+ ];
+
+ pub static S_table: &'static [(char, char)] = &[
+ ('\x24', '\x24'), ('\x2b', '\x2b'), ('\x3c', '\x3e'), ('\x5e', '\x5e'), ('\x60', '\x60'),
+ ('\x7c', '\x7c'), ('\x7e', '\x7e'), ('\xa2', '\xa6'), ('\xa8', '\xa9'), ('\xac', '\xac'),
+ ('\xae', '\xb1'), ('\xb4', '\xb4'), ('\xb8', '\xb8'), ('\xd7', '\xd7'), ('\xf7', '\xf7'),
+ ('\u02c2', '\u02c5'), ('\u02d2', '\u02df'), ('\u02e5', '\u02eb'), ('\u02ed', '\u02ed'),
+ ('\u02ef', '\u02ff'), ('\u0375', '\u0375'), ('\u0384', '\u0385'), ('\u03f6', '\u03f6'),
+ ('\u0482', '\u0482'), ('\u058d', '\u058f'), ('\u0606', '\u0608'), ('\u060b', '\u060b'),
+ ('\u060e', '\u060f'), ('\u06de', '\u06de'), ('\u06e9', '\u06e9'), ('\u06fd', '\u06fe'),
+ ('\u07f6', '\u07f6'), ('\u09f2', '\u09f3'), ('\u09fa', '\u09fb'), ('\u0af1', '\u0af1'),
+ ('\u0b70', '\u0b70'), ('\u0bf3', '\u0bfa'), ('\u0c7f', '\u0c7f'), ('\u0d79', '\u0d79'),
+ ('\u0e3f', '\u0e3f'), ('\u0f01', '\u0f03'), ('\u0f13', '\u0f13'), ('\u0f15', '\u0f17'),
+ ('\u0f1a', '\u0f1f'), ('\u0f34', '\u0f34'), ('\u0f36', '\u0f36'), ('\u0f38', '\u0f38'),
+ ('\u0fbe', '\u0fc5'), ('\u0fc7', '\u0fcc'), ('\u0fce', '\u0fcf'), ('\u0fd5', '\u0fd8'),
+ ('\u109e', '\u109f'), ('\u1390', '\u1399'), ('\u17db', '\u17db'), ('\u1940', '\u1940'),
+ ('\u19de', '\u19ff'), ('\u1b61', '\u1b6a'), ('\u1b74', '\u1b7c'), ('\u1fbd', '\u1fbd'),
+ ('\u1fbf', '\u1fc1'), ('\u1fcd', '\u1fcf'), ('\u1fdd', '\u1fdf'), ('\u1fed', '\u1fef'),
+ ('\u1ffd', '\u1ffe'), ('\u2044', '\u2044'), ('\u2052', '\u2052'), ('\u207a', '\u207c'),
+ ('\u208a', '\u208c'), ('\u20a0', '\u20bd'), ('\u2100', '\u2101'), ('\u2103', '\u2106'),
+ ('\u2108', '\u2109'), ('\u2114', '\u2114'), ('\u2116', '\u2118'), ('\u211e', '\u2123'),
+ ('\u2125', '\u2125'), ('\u2127', '\u2127'), ('\u2129', '\u2129'), ('\u212e', '\u212e'),
+ ('\u213a', '\u213b'), ('\u2140', '\u2144'), ('\u214a', '\u214d'), ('\u214f', '\u214f'),
+ ('\u2190', '\u2307'), ('\u230c', '\u2328'), ('\u232b', '\u23fa'), ('\u2400', '\u2426'),
+ ('\u2440', '\u244a'), ('\u249c', '\u24e9'), ('\u2500', '\u2767'), ('\u2794', '\u27c4'),
+ ('\u27c7', '\u27e5'), ('\u27f0', '\u2982'), ('\u2999', '\u29d7'), ('\u29dc', '\u29fb'),
+ ('\u29fe', '\u2b73'), ('\u2b76', '\u2b95'), ('\u2b98', '\u2bb9'), ('\u2bbd', '\u2bc8'),
+ ('\u2bca', '\u2bd1'), ('\u2ce5', '\u2cea'), ('\u2e80', '\u2e99'), ('\u2e9b', '\u2ef3'),
+ ('\u2f00', '\u2fd5'), ('\u2ff0', '\u2ffb'), ('\u3004', '\u3004'), ('\u3012', '\u3013'),
+ ('\u3020', '\u3020'), ('\u3036', '\u3037'), ('\u303e', '\u303f'), ('\u309b', '\u309c'),
+ ('\u3190', '\u3191'), ('\u3196', '\u319f'), ('\u31c0', '\u31e3'), ('\u3200', '\u321e'),
+ ('\u322a', '\u3247'), ('\u3250', '\u3250'), ('\u3260', '\u327f'), ('\u328a', '\u32b0'),
+ ('\u32c0', '\u32fe'), ('\u3300', '\u33ff'), ('\u4dc0', '\u4dff'), ('\ua490', '\ua4c6'),
+ ('\ua700', '\ua716'), ('\ua720', '\ua721'), ('\ua789', '\ua78a'), ('\ua828', '\ua82b'),
+ ('\ua836', '\ua839'), ('\uaa77', '\uaa79'), ('\uab5b', '\uab5b'), ('\ufb29', '\ufb29'),
+ ('\ufbb2', '\ufbc1'), ('\ufdfc', '\ufdfd'), ('\ufe62', '\ufe62'), ('\ufe64', '\ufe66'),
+ ('\ufe69', '\ufe69'), ('\uff04', '\uff04'), ('\uff0b', '\uff0b'), ('\uff1c', '\uff1e'),
+ ('\uff3e', '\uff3e'), ('\uff40', '\uff40'), ('\uff5c', '\uff5c'), ('\uff5e', '\uff5e'),
+ ('\uffe0', '\uffe6'), ('\uffe8', '\uffee'), ('\ufffc', '\ufffd'), ('\U00010137',
+ '\U0001013f'), ('\U00010179', '\U00010189'), ('\U0001018c', '\U0001018c'), ('\U00010190',
+ '\U0001019b'), ('\U000101a0', '\U000101a0'), ('\U000101d0', '\U000101fc'), ('\U00010877',
+ '\U00010878'), ('\U00010ac8', '\U00010ac8'), ('\U00016b3c', '\U00016b3f'), ('\U00016b45',
+ '\U00016b45'), ('\U0001bc9c', '\U0001bc9c'), ('\U0001d000', '\U0001d0f5'), ('\U0001d100',
+ '\U0001d126'), ('\U0001d129', '\U0001d164'), ('\U0001d16a', '\U0001d16c'), ('\U0001d183',
+ '\U0001d184'), ('\U0001d18c', '\U0001d1a9'), ('\U0001d1ae', '\U0001d1dd'), ('\U0001d200',
+ '\U0001d241'), ('\U0001d245', '\U0001d245'), ('\U0001d300', '\U0001d356'), ('\U0001d6c1',
+ '\U0001d6c1'), ('\U0001d6db', '\U0001d6db'), ('\U0001d6fb', '\U0001d6fb'), ('\U0001d715',
+ '\U0001d715'), ('\U0001d735', '\U0001d735'), ('\U0001d74f', '\U0001d74f'), ('\U0001d76f',
+ '\U0001d76f'), ('\U0001d789', '\U0001d789'), ('\U0001d7a9', '\U0001d7a9'), ('\U0001d7c3',
+ '\U0001d7c3'), ('\U0001eef0', '\U0001eef1'), ('\U0001f000', '\U0001f02b'), ('\U0001f030',
+ '\U0001f093'), ('\U0001f0a0', '\U0001f0ae'), ('\U0001f0b1', '\U0001f0bf'), ('\U0001f0c1',
+ '\U0001f0cf'), ('\U0001f0d1', '\U0001f0f5'), ('\U0001f110', '\U0001f12e'), ('\U0001f130',
+ '\U0001f16b'), ('\U0001f170', '\U0001f19a'), ('\U0001f1e6', '\U0001f202'), ('\U0001f210',
+ '\U0001f23a'), ('\U0001f240', '\U0001f248'), ('\U0001f250', '\U0001f251'), ('\U0001f300',
+ '\U0001f32c'), ('\U0001f330', '\U0001f37d'), ('\U0001f380', '\U0001f3ce'), ('\U0001f3d4',
+ '\U0001f3f7'), ('\U0001f400', '\U0001f4fe'), ('\U0001f500', '\U0001f54a'), ('\U0001f550',
+ '\U0001f579'), ('\U0001f57b', '\U0001f5a3'), ('\U0001f5a5', '\U0001f642'), ('\U0001f645',
+ '\U0001f6cf'), ('\U0001f6e0', '\U0001f6ec'), ('\U0001f6f0', '\U0001f6f3'), ('\U0001f700',
+ '\U0001f773'), ('\U0001f780', '\U0001f7d4'), ('\U0001f800', '\U0001f80b'), ('\U0001f810',
+ '\U0001f847'), ('\U0001f850', '\U0001f859'), ('\U0001f860', '\U0001f887'), ('\U0001f890',
+ '\U0001f8ad')
+ ];
+
+ pub static Sc_table: &'static [(char, char)] = &[
+ ('\x24', '\x24'), ('\xa2', '\xa5'), ('\u058f', '\u058f'), ('\u060b', '\u060b'), ('\u09f2',
+ '\u09f3'), ('\u09fb', '\u09fb'), ('\u0af1', '\u0af1'), ('\u0bf9', '\u0bf9'), ('\u0e3f',
+ '\u0e3f'), ('\u17db', '\u17db'), ('\u20a0', '\u20bd'), ('\ua838', '\ua838'), ('\ufdfc',
+ '\ufdfc'), ('\ufe69', '\ufe69'), ('\uff04', '\uff04'), ('\uffe0', '\uffe1'), ('\uffe5',
+ '\uffe6')
+ ];
+
+ pub static Sk_table: &'static [(char, char)] = &[
+ ('\x5e', '\x5e'), ('\x60', '\x60'), ('\xa8', '\xa8'), ('\xaf', '\xaf'), ('\xb4', '\xb4'),
+ ('\xb8', '\xb8'), ('\u02c2', '\u02c5'), ('\u02d2', '\u02df'), ('\u02e5', '\u02eb'),
+ ('\u02ed', '\u02ed'), ('\u02ef', '\u02ff'), ('\u0375', '\u0375'), ('\u0384', '\u0385'),
+ ('\u1fbd', '\u1fbd'), ('\u1fbf', '\u1fc1'), ('\u1fcd', '\u1fcf'), ('\u1fdd', '\u1fdf'),
+ ('\u1fed', '\u1fef'), ('\u1ffd', '\u1ffe'), ('\u309b', '\u309c'), ('\ua700', '\ua716'),
+ ('\ua720', '\ua721'), ('\ua789', '\ua78a'), ('\uab5b', '\uab5b'), ('\ufbb2', '\ufbc1'),
+ ('\uff3e', '\uff3e'), ('\uff40', '\uff40'), ('\uffe3', '\uffe3')
+ ];
+
+ pub static Sm_table: &'static [(char, char)] = &[
+ ('\x2b', '\x2b'), ('\x3c', '\x3e'), ('\x7c', '\x7c'), ('\x7e', '\x7e'), ('\xac', '\xac'),
+ ('\xb1', '\xb1'), ('\xd7', '\xd7'), ('\xf7', '\xf7'), ('\u03f6', '\u03f6'), ('\u0606',
+ '\u0608'), ('\u2044', '\u2044'), ('\u2052', '\u2052'), ('\u207a', '\u207c'), ('\u208a',
+ '\u208c'), ('\u2118', '\u2118'), ('\u2140', '\u2144'), ('\u214b', '\u214b'), ('\u2190',
+ '\u2194'), ('\u219a', '\u219b'), ('\u21a0', '\u21a0'), ('\u21a3', '\u21a3'), ('\u21a6',
+ '\u21a6'), ('\u21ae', '\u21ae'), ('\u21ce', '\u21cf'), ('\u21d2', '\u21d2'), ('\u21d4',
+ '\u21d4'), ('\u21f4', '\u22ff'), ('\u2320', '\u2321'), ('\u237c', '\u237c'), ('\u239b',
+ '\u23b3'), ('\u23dc', '\u23e1'), ('\u25b7', '\u25b7'), ('\u25c1', '\u25c1'), ('\u25f8',
+ '\u25ff'), ('\u266f', '\u266f'), ('\u27c0', '\u27c4'), ('\u27c7', '\u27e5'), ('\u27f0',
+ '\u27ff'), ('\u2900', '\u2982'), ('\u2999', '\u29d7'), ('\u29dc', '\u29fb'), ('\u29fe',
+ '\u2aff'), ('\u2b30', '\u2b44'), ('\u2b47', '\u2b4c'), ('\ufb29', '\ufb29'), ('\ufe62',
+ '\ufe62'), ('\ufe64', '\ufe66'), ('\uff0b', '\uff0b'), ('\uff1c', '\uff1e'), ('\uff5c',
+ '\uff5c'), ('\uff5e', '\uff5e'), ('\uffe2', '\uffe2'), ('\uffe9', '\uffec'), ('\U0001d6c1',
+ '\U0001d6c1'), ('\U0001d6db', '\U0001d6db'), ('\U0001d6fb', '\U0001d6fb'), ('\U0001d715',
+ '\U0001d715'), ('\U0001d735', '\U0001d735'), ('\U0001d74f', '\U0001d74f'), ('\U0001d76f',
+ '\U0001d76f'), ('\U0001d789', '\U0001d789'), ('\U0001d7a9', '\U0001d7a9'), ('\U0001d7c3',
+ '\U0001d7c3'), ('\U0001eef0', '\U0001eef1')
+ ];
+
+ pub static So_table: &'static [(char, char)] = &[
+ ('\xa6', '\xa6'), ('\xa9', '\xa9'), ('\xae', '\xae'), ('\xb0', '\xb0'), ('\u0482',
+ '\u0482'), ('\u058d', '\u058e'), ('\u060e', '\u060f'), ('\u06de', '\u06de'), ('\u06e9',
+ '\u06e9'), ('\u06fd', '\u06fe'), ('\u07f6', '\u07f6'), ('\u09fa', '\u09fa'), ('\u0b70',
+ '\u0b70'), ('\u0bf3', '\u0bf8'), ('\u0bfa', '\u0bfa'), ('\u0c7f', '\u0c7f'), ('\u0d79',
+ '\u0d79'), ('\u0f01', '\u0f03'), ('\u0f13', '\u0f13'), ('\u0f15', '\u0f17'), ('\u0f1a',
+ '\u0f1f'), ('\u0f34', '\u0f34'), ('\u0f36', '\u0f36'), ('\u0f38', '\u0f38'), ('\u0fbe',
+ '\u0fc5'), ('\u0fc7', '\u0fcc'), ('\u0fce', '\u0fcf'), ('\u0fd5', '\u0fd8'), ('\u109e',
+ '\u109f'), ('\u1390', '\u1399'), ('\u1940', '\u1940'), ('\u19de', '\u19ff'), ('\u1b61',
+ '\u1b6a'), ('\u1b74', '\u1b7c'), ('\u2100', '\u2101'), ('\u2103', '\u2106'), ('\u2108',
+ '\u2109'), ('\u2114', '\u2114'), ('\u2116', '\u2117'), ('\u211e', '\u2123'), ('\u2125',
+ '\u2125'), ('\u2127', '\u2127'), ('\u2129', '\u2129'), ('\u212e', '\u212e'), ('\u213a',
+ '\u213b'), ('\u214a', '\u214a'), ('\u214c', '\u214d'), ('\u214f', '\u214f'), ('\u2195',
+ '\u2199'), ('\u219c', '\u219f'), ('\u21a1', '\u21a2'), ('\u21a4', '\u21a5'), ('\u21a7',
+ '\u21ad'), ('\u21af', '\u21cd'), ('\u21d0', '\u21d1'), ('\u21d3', '\u21d3'), ('\u21d5',
+ '\u21f3'), ('\u2300', '\u2307'), ('\u230c', '\u231f'), ('\u2322', '\u2328'), ('\u232b',
+ '\u237b'), ('\u237d', '\u239a'), ('\u23b4', '\u23db'), ('\u23e2', '\u23fa'), ('\u2400',
+ '\u2426'), ('\u2440', '\u244a'), ('\u249c', '\u24e9'), ('\u2500', '\u25b6'), ('\u25b8',
+ '\u25c0'), ('\u25c2', '\u25f7'), ('\u2600', '\u266e'), ('\u2670', '\u2767'), ('\u2794',
+ '\u27bf'), ('\u2800', '\u28ff'), ('\u2b00', '\u2b2f'), ('\u2b45', '\u2b46'), ('\u2b4d',
+ '\u2b73'), ('\u2b76', '\u2b95'), ('\u2b98', '\u2bb9'), ('\u2bbd', '\u2bc8'), ('\u2bca',
+ '\u2bd1'), ('\u2ce5', '\u2cea'), ('\u2e80', '\u2e99'), ('\u2e9b', '\u2ef3'), ('\u2f00',
+ '\u2fd5'), ('\u2ff0', '\u2ffb'), ('\u3004', '\u3004'), ('\u3012', '\u3013'), ('\u3020',
+ '\u3020'), ('\u3036', '\u3037'), ('\u303e', '\u303f'), ('\u3190', '\u3191'), ('\u3196',
+ '\u319f'), ('\u31c0', '\u31e3'), ('\u3200', '\u321e'), ('\u322a', '\u3247'), ('\u3250',
+ '\u3250'), ('\u3260', '\u327f'), ('\u328a', '\u32b0'), ('\u32c0', '\u32fe'), ('\u3300',
+ '\u33ff'), ('\u4dc0', '\u4dff'), ('\ua490', '\ua4c6'), ('\ua828', '\ua82b'), ('\ua836',
+ '\ua837'), ('\ua839', '\ua839'), ('\uaa77', '\uaa79'), ('\ufdfd', '\ufdfd'), ('\uffe4',
+ '\uffe4'), ('\uffe8', '\uffe8'), ('\uffed', '\uffee'), ('\ufffc', '\ufffd'), ('\U00010137',
+ '\U0001013f'), ('\U00010179', '\U00010189'), ('\U0001018c', '\U0001018c'), ('\U00010190',
+ '\U0001019b'), ('\U000101a0', '\U000101a0'), ('\U000101d0', '\U000101fc'), ('\U00010877',
+ '\U00010878'), ('\U00010ac8', '\U00010ac8'), ('\U00016b3c', '\U00016b3f'), ('\U00016b45',
+ '\U00016b45'), ('\U0001bc9c', '\U0001bc9c'), ('\U0001d000', '\U0001d0f5'), ('\U0001d100',
+ '\U0001d126'), ('\U0001d129', '\U0001d164'), ('\U0001d16a', '\U0001d16c'), ('\U0001d183',
+ '\U0001d184'), ('\U0001d18c', '\U0001d1a9'), ('\U0001d1ae', '\U0001d1dd'), ('\U0001d200',
+ '\U0001d241'), ('\U0001d245', '\U0001d245'), ('\U0001d300', '\U0001d356'), ('\U0001f000',
+ '\U0001f02b'), ('\U0001f030', '\U0001f093'), ('\U0001f0a0', '\U0001f0ae'), ('\U0001f0b1',
+ '\U0001f0bf'), ('\U0001f0c1', '\U0001f0cf'), ('\U0001f0d1', '\U0001f0f5'), ('\U0001f110',
+ '\U0001f12e'), ('\U0001f130', '\U0001f16b'), ('\U0001f170', '\U0001f19a'), ('\U0001f1e6',
+ '\U0001f202'), ('\U0001f210', '\U0001f23a'), ('\U0001f240', '\U0001f248'), ('\U0001f250',
+ '\U0001f251'), ('\U0001f300', '\U0001f32c'), ('\U0001f330', '\U0001f37d'), ('\U0001f380',
+ '\U0001f3ce'), ('\U0001f3d4', '\U0001f3f7'), ('\U0001f400', '\U0001f4fe'), ('\U0001f500',
+ '\U0001f54a'), ('\U0001f550', '\U0001f579'), ('\U0001f57b', '\U0001f5a3'), ('\U0001f5a5',
+ '\U0001f642'), ('\U0001f645', '\U0001f6cf'), ('\U0001f6e0', '\U0001f6ec'), ('\U0001f6f0',
+ '\U0001f6f3'), ('\U0001f700', '\U0001f773'), ('\U0001f780', '\U0001f7d4'), ('\U0001f800',
+ '\U0001f80b'), ('\U0001f810', '\U0001f847'), ('\U0001f850', '\U0001f859'), ('\U0001f860',
+ '\U0001f887'), ('\U0001f890', '\U0001f8ad')
+ ];
+
+ pub static Z_table: &'static [(char, char)] = &[
+ ('\x20', '\x20'), ('\xa0', '\xa0'), ('\u1680', '\u1680'), ('\u2000', '\u200a'), ('\u2028',
+ '\u2029'), ('\u202f', '\u202f'), ('\u205f', '\u205f'), ('\u3000', '\u3000')
+ ];
+
+ pub static Zl_table: &'static [(char, char)] = &[
+ ('\u2028', '\u2028')
+ ];
+
+ pub static Zp_table: &'static [(char, char)] = &[
+ ('\u2029', '\u2029')
+ ];
+
+ pub static Zs_table: &'static [(char, char)] = &[
+ ('\x20', '\x20'), ('\xa0', '\xa0'), ('\u1680', '\u1680'), ('\u2000', '\u200a'), ('\u202f',
+ '\u202f'), ('\u205f', '\u205f'), ('\u3000', '\u3000')
+ ];
+
+}
+
+pub mod derived_property {
+ pub static Alphabetic_table: &'static [(char, char)] = &[
+ ('\x41', '\x5a'), ('\x61', '\x7a'), ('\xaa', '\xaa'), ('\xb5', '\xb5'), ('\xba', '\xba'),
+ ('\xc0', '\xd6'), ('\xd8', '\xf6'), ('\xf8', '\u01ba'), ('\u01bb', '\u01bb'), ('\u01bc',
+ '\u01bf'), ('\u01c0', '\u01c3'), ('\u01c4', '\u0293'), ('\u0294', '\u0294'), ('\u0295',
+ '\u02af'), ('\u02b0', '\u02c1'), ('\u02c6', '\u02d1'), ('\u02e0', '\u02e4'), ('\u02ec',
+ '\u02ec'), ('\u02ee', '\u02ee'), ('\u0345', '\u0345'), ('\u0370', '\u0373'), ('\u0374',
+ '\u0374'), ('\u0376', '\u0377'), ('\u037a', '\u037a'), ('\u037b', '\u037d'), ('\u037f',
+ '\u037f'), ('\u0386', '\u0386'), ('\u0388', '\u038a'), ('\u038c', '\u038c'), ('\u038e',
+ '\u03a1'), ('\u03a3', '\u03f5'), ('\u03f7', '\u0481'), ('\u048a', '\u052f'), ('\u0531',
+ '\u0556'), ('\u0559', '\u0559'), ('\u0561', '\u0587'), ('\u05b0', '\u05bd'), ('\u05bf',
+ '\u05bf'), ('\u05c1', '\u05c2'), ('\u05c4', '\u05c5'), ('\u05c7', '\u05c7'), ('\u05d0',
+ '\u05ea'), ('\u05f0', '\u05f2'), ('\u0610', '\u061a'), ('\u0620', '\u063f'), ('\u0640',
+ '\u0640'), ('\u0641', '\u064a'), ('\u064b', '\u0657'), ('\u0659', '\u065f'), ('\u066e',
+ '\u066f'), ('\u0670', '\u0670'), ('\u0671', '\u06d3'), ('\u06d5', '\u06d5'), ('\u06d6',
+ '\u06dc'), ('\u06e1', '\u06e4'), ('\u06e5', '\u06e6'), ('\u06e7', '\u06e8'), ('\u06ed',
+ '\u06ed'), ('\u06ee', '\u06ef'), ('\u06fa', '\u06fc'), ('\u06ff', '\u06ff'), ('\u0710',
+ '\u0710'), ('\u0711', '\u0711'), ('\u0712', '\u072f'), ('\u0730', '\u073f'), ('\u074d',
+ '\u07a5'), ('\u07a6', '\u07b0'), ('\u07b1', '\u07b1'), ('\u07ca', '\u07ea'), ('\u07f4',
+ '\u07f5'), ('\u07fa', '\u07fa'), ('\u0800', '\u0815'), ('\u0816', '\u0817'), ('\u081a',
+ '\u081a'), ('\u081b', '\u0823'), ('\u0824', '\u0824'), ('\u0825', '\u0827'), ('\u0828',
+ '\u0828'), ('\u0829', '\u082c'), ('\u0840', '\u0858'), ('\u08a0', '\u08b2'), ('\u08e4',
+ '\u08e9'), ('\u08f0', '\u0902'), ('\u0903', '\u0903'), ('\u0904', '\u0939'), ('\u093a',
+ '\u093a'), ('\u093b', '\u093b'), ('\u093d', '\u093d'), ('\u093e', '\u0940'), ('\u0941',
+ '\u0948'), ('\u0949', '\u094c'), ('\u094e', '\u094f'), ('\u0950', '\u0950'), ('\u0955',
+ '\u0957'), ('\u0958', '\u0961'), ('\u0962', '\u0963'), ('\u0971', '\u0971'), ('\u0972',
+ '\u0980'), ('\u0981', '\u0981'), ('\u0982', '\u0983'), ('\u0985', '\u098c'), ('\u098f',
+ '\u0990'), ('\u0993', '\u09a8'), ('\u09aa', '\u09b0'), ('\u09b2', '\u09b2'), ('\u09b6',
+ '\u09b9'), ('\u09bd', '\u09bd'), ('\u09be', '\u09c0'), ('\u09c1', '\u09c4'), ('\u09c7',
+ '\u09c8'), ('\u09cb', '\u09cc'), ('\u09ce', '\u09ce'), ('\u09d7', '\u09d7'), ('\u09dc',
+ '\u09dd'), ('\u09df', '\u09e1'), ('\u09e2', '\u09e3'), ('\u09f0', '\u09f1'), ('\u0a01',
+ '\u0a02'), ('\u0a03', '\u0a03'), ('\u0a05', '\u0a0a'), ('\u0a0f', '\u0a10'), ('\u0a13',
+ '\u0a28'), ('\u0a2a', '\u0a30'), ('\u0a32', '\u0a33'), ('\u0a35', '\u0a36'), ('\u0a38',
+ '\u0a39'), ('\u0a3e', '\u0a40'), ('\u0a41', '\u0a42'), ('\u0a47', '\u0a48'), ('\u0a4b',
+ '\u0a4c'), ('\u0a51', '\u0a51'), ('\u0a59', '\u0a5c'), ('\u0a5e', '\u0a5e'), ('\u0a70',
+ '\u0a71'), ('\u0a72', '\u0a74'), ('\u0a75', '\u0a75'), ('\u0a81', '\u0a82'), ('\u0a83',
+ '\u0a83'), ('\u0a85', '\u0a8d'), ('\u0a8f', '\u0a91'), ('\u0a93', '\u0aa8'), ('\u0aaa',
+ '\u0ab0'), ('\u0ab2', '\u0ab3'), ('\u0ab5', '\u0ab9'), ('\u0abd', '\u0abd'), ('\u0abe',
+ '\u0ac0'), ('\u0ac1', '\u0ac5'), ('\u0ac7', '\u0ac8'), ('\u0ac9', '\u0ac9'), ('\u0acb',
+ '\u0acc'), ('\u0ad0', '\u0ad0'), ('\u0ae0', '\u0ae1'), ('\u0ae2', '\u0ae3'), ('\u0b01',
+ '\u0b01'), ('\u0b02', '\u0b03'), ('\u0b05', '\u0b0c'), ('\u0b0f', '\u0b10'), ('\u0b13',
+ '\u0b28'), ('\u0b2a', '\u0b30'), ('\u0b32', '\u0b33'), ('\u0b35', '\u0b39'), ('\u0b3d',
+ '\u0b3d'), ('\u0b3e', '\u0b3e'), ('\u0b3f', '\u0b3f'), ('\u0b40', '\u0b40'), ('\u0b41',
+ '\u0b44'), ('\u0b47', '\u0b48'), ('\u0b4b', '\u0b4c'), ('\u0b56', '\u0b56'), ('\u0b57',
+ '\u0b57'), ('\u0b5c', '\u0b5d'), ('\u0b5f', '\u0b61'), ('\u0b62', '\u0b63'), ('\u0b71',
+ '\u0b71'), ('\u0b82', '\u0b82'), ('\u0b83', '\u0b83'), ('\u0b85', '\u0b8a'), ('\u0b8e',
+ '\u0b90'), ('\u0b92', '\u0b95'), ('\u0b99', '\u0b9a'), ('\u0b9c', '\u0b9c'), ('\u0b9e',
+ '\u0b9f'), ('\u0ba3', '\u0ba4'), ('\u0ba8', '\u0baa'), ('\u0bae', '\u0bb9'), ('\u0bbe',
+ '\u0bbf'), ('\u0bc0', '\u0bc0'), ('\u0bc1', '\u0bc2'), ('\u0bc6', '\u0bc8'), ('\u0bca',
+ '\u0bcc'), ('\u0bd0', '\u0bd0'), ('\u0bd7', '\u0bd7'), ('\u0c00', '\u0c00'), ('\u0c01',
+ '\u0c03'), ('\u0c05', '\u0c0c'), ('\u0c0e', '\u0c10'), ('\u0c12', '\u0c28'), ('\u0c2a',
+ '\u0c39'), ('\u0c3d', '\u0c3d'), ('\u0c3e', '\u0c40'), ('\u0c41', '\u0c44'), ('\u0c46',
+ '\u0c48'), ('\u0c4a', '\u0c4c'), ('\u0c55', '\u0c56'), ('\u0c58', '\u0c59'), ('\u0c60',
+ '\u0c61'), ('\u0c62', '\u0c63'), ('\u0c81', '\u0c81'), ('\u0c82', '\u0c83'), ('\u0c85',
+ '\u0c8c'), ('\u0c8e', '\u0c90'), ('\u0c92', '\u0ca8'), ('\u0caa', '\u0cb3'), ('\u0cb5',
+ '\u0cb9'), ('\u0cbd', '\u0cbd'), ('\u0cbe', '\u0cbe'), ('\u0cbf', '\u0cbf'), ('\u0cc0',
+ '\u0cc4'), ('\u0cc6', '\u0cc6'), ('\u0cc7', '\u0cc8'), ('\u0cca', '\u0ccb'), ('\u0ccc',
+ '\u0ccc'), ('\u0cd5', '\u0cd6'), ('\u0cde', '\u0cde'), ('\u0ce0', '\u0ce1'), ('\u0ce2',
+ '\u0ce3'), ('\u0cf1', '\u0cf2'), ('\u0d01', '\u0d01'), ('\u0d02', '\u0d03'), ('\u0d05',
+ '\u0d0c'), ('\u0d0e', '\u0d10'), ('\u0d12', '\u0d3a'), ('\u0d3d', '\u0d3d'), ('\u0d3e',
+ '\u0d40'), ('\u0d41', '\u0d44'), ('\u0d46', '\u0d48'), ('\u0d4a', '\u0d4c'), ('\u0d4e',
+ '\u0d4e'), ('\u0d57', '\u0d57'), ('\u0d60', '\u0d61'), ('\u0d62', '\u0d63'), ('\u0d7a',
+ '\u0d7f'), ('\u0d82', '\u0d83'), ('\u0d85', '\u0d96'), ('\u0d9a', '\u0db1'), ('\u0db3',
+ '\u0dbb'), ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'), ('\u0dcf', '\u0dd1'), ('\u0dd2',
+ '\u0dd4'), ('\u0dd6', '\u0dd6'), ('\u0dd8', '\u0ddf'), ('\u0df2', '\u0df3'), ('\u0e01',
+ '\u0e30'), ('\u0e31', '\u0e31'), ('\u0e32', '\u0e33'), ('\u0e34', '\u0e3a'), ('\u0e40',
+ '\u0e45'), ('\u0e46', '\u0e46'), ('\u0e4d', '\u0e4d'), ('\u0e81', '\u0e82'), ('\u0e84',
+ '\u0e84'), ('\u0e87', '\u0e88'), ('\u0e8a', '\u0e8a'), ('\u0e8d', '\u0e8d'), ('\u0e94',
+ '\u0e97'), ('\u0e99', '\u0e9f'), ('\u0ea1', '\u0ea3'), ('\u0ea5', '\u0ea5'), ('\u0ea7',
+ '\u0ea7'), ('\u0eaa', '\u0eab'), ('\u0ead', '\u0eb0'), ('\u0eb1', '\u0eb1'), ('\u0eb2',
+ '\u0eb3'), ('\u0eb4', '\u0eb9'), ('\u0ebb', '\u0ebc'), ('\u0ebd', '\u0ebd'), ('\u0ec0',
+ '\u0ec4'), ('\u0ec6', '\u0ec6'), ('\u0ecd', '\u0ecd'), ('\u0edc', '\u0edf'), ('\u0f00',
+ '\u0f00'), ('\u0f40', '\u0f47'), ('\u0f49', '\u0f6c'), ('\u0f71', '\u0f7e'), ('\u0f7f',
+ '\u0f7f'), ('\u0f80', '\u0f81'), ('\u0f88', '\u0f8c'), ('\u0f8d', '\u0f97'), ('\u0f99',
+ '\u0fbc'), ('\u1000', '\u102a'), ('\u102b', '\u102c'), ('\u102d', '\u1030'), ('\u1031',
+ '\u1031'), ('\u1032', '\u1036'), ('\u1038', '\u1038'), ('\u103b', '\u103c'), ('\u103d',
+ '\u103e'), ('\u103f', '\u103f'), ('\u1050', '\u1055'), ('\u1056', '\u1057'), ('\u1058',
+ '\u1059'), ('\u105a', '\u105d'), ('\u105e', '\u1060'), ('\u1061', '\u1061'), ('\u1062',
+ '\u1062'), ('\u1065', '\u1066'), ('\u1067', '\u1068'), ('\u106e', '\u1070'), ('\u1071',
+ '\u1074'), ('\u1075', '\u1081'), ('\u1082', '\u1082'), ('\u1083', '\u1084'), ('\u1085',
+ '\u1086'), ('\u108e', '\u108e'), ('\u109c', '\u109c'), ('\u109d', '\u109d'), ('\u10a0',
+ '\u10c5'), ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'), ('\u10d0', '\u10fa'), ('\u10fc',
+ '\u10fc'), ('\u10fd', '\u1248'), ('\u124a', '\u124d'), ('\u1250', '\u1256'), ('\u1258',
+ '\u1258'), ('\u125a', '\u125d'), ('\u1260', '\u1288'), ('\u128a', '\u128d'), ('\u1290',
+ '\u12b0'), ('\u12b2', '\u12b5'), ('\u12b8', '\u12be'), ('\u12c0', '\u12c0'), ('\u12c2',
+ '\u12c5'), ('\u12c8', '\u12d6'), ('\u12d8', '\u1310'), ('\u1312', '\u1315'), ('\u1318',
+ '\u135a'), ('\u135f', '\u135f'), ('\u1380', '\u138f'), ('\u13a0', '\u13f4'), ('\u1401',
+ '\u166c'), ('\u166f', '\u167f'), ('\u1681', '\u169a'), ('\u16a0', '\u16ea'), ('\u16ee',
+ '\u16f0'), ('\u16f1', '\u16f8'), ('\u1700', '\u170c'), ('\u170e', '\u1711'), ('\u1712',
+ '\u1713'), ('\u1720', '\u1731'), ('\u1732', '\u1733'), ('\u1740', '\u1751'), ('\u1752',
+ '\u1753'), ('\u1760', '\u176c'), ('\u176e', '\u1770'), ('\u1772', '\u1773'), ('\u1780',
+ '\u17b3'), ('\u17b6', '\u17b6'), ('\u17b7', '\u17bd'), ('\u17be', '\u17c5'), ('\u17c6',
+ '\u17c6'), ('\u17c7', '\u17c8'), ('\u17d7', '\u17d7'), ('\u17dc', '\u17dc'), ('\u1820',
+ '\u1842'), ('\u1843', '\u1843'), ('\u1844', '\u1877'), ('\u1880', '\u18a8'), ('\u18a9',
+ '\u18a9'), ('\u18aa', '\u18aa'), ('\u18b0', '\u18f5'), ('\u1900', '\u191e'), ('\u1920',
+ '\u1922'), ('\u1923', '\u1926'), ('\u1927', '\u1928'), ('\u1929', '\u192b'), ('\u1930',
+ '\u1931'), ('\u1932', '\u1932'), ('\u1933', '\u1938'), ('\u1950', '\u196d'), ('\u1970',
+ '\u1974'), ('\u1980', '\u19ab'), ('\u19b0', '\u19c0'), ('\u19c1', '\u19c7'), ('\u19c8',
+ '\u19c9'), ('\u1a00', '\u1a16'), ('\u1a17', '\u1a18'), ('\u1a19', '\u1a1a'), ('\u1a1b',
+ '\u1a1b'), ('\u1a20', '\u1a54'), ('\u1a55', '\u1a55'), ('\u1a56', '\u1a56'), ('\u1a57',
+ '\u1a57'), ('\u1a58', '\u1a5e'), ('\u1a61', '\u1a61'), ('\u1a62', '\u1a62'), ('\u1a63',
+ '\u1a64'), ('\u1a65', '\u1a6c'), ('\u1a6d', '\u1a72'), ('\u1a73', '\u1a74'), ('\u1aa7',
+ '\u1aa7'), ('\u1b00', '\u1b03'), ('\u1b04', '\u1b04'), ('\u1b05', '\u1b33'), ('\u1b35',
+ '\u1b35'), ('\u1b36', '\u1b3a'), ('\u1b3b', '\u1b3b'), ('\u1b3c', '\u1b3c'), ('\u1b3d',
+ '\u1b41'), ('\u1b42', '\u1b42'), ('\u1b43', '\u1b43'), ('\u1b45', '\u1b4b'), ('\u1b80',
+ '\u1b81'), ('\u1b82', '\u1b82'), ('\u1b83', '\u1ba0'), ('\u1ba1', '\u1ba1'), ('\u1ba2',
+ '\u1ba5'), ('\u1ba6', '\u1ba7'), ('\u1ba8', '\u1ba9'), ('\u1bac', '\u1bad'), ('\u1bae',
+ '\u1baf'), ('\u1bba', '\u1be5'), ('\u1be7', '\u1be7'), ('\u1be8', '\u1be9'), ('\u1bea',
+ '\u1bec'), ('\u1bed', '\u1bed'), ('\u1bee', '\u1bee'), ('\u1bef', '\u1bf1'), ('\u1c00',
+ '\u1c23'), ('\u1c24', '\u1c2b'), ('\u1c2c', '\u1c33'), ('\u1c34', '\u1c35'), ('\u1c4d',
+ '\u1c4f'), ('\u1c5a', '\u1c77'), ('\u1c78', '\u1c7d'), ('\u1ce9', '\u1cec'), ('\u1cee',
+ '\u1cf1'), ('\u1cf2', '\u1cf3'), ('\u1cf5', '\u1cf6'), ('\u1d00', '\u1d2b'), ('\u1d2c',
+ '\u1d6a'), ('\u1d6b', '\u1d77'), ('\u1d78', '\u1d78'), ('\u1d79', '\u1d9a'), ('\u1d9b',
+ '\u1dbf'), ('\u1de7', '\u1df4'), ('\u1e00', '\u1f15'), ('\u1f18', '\u1f1d'), ('\u1f20',
+ '\u1f45'), ('\u1f48', '\u1f4d'), ('\u1f50', '\u1f57'), ('\u1f59', '\u1f59'), ('\u1f5b',
+ '\u1f5b'), ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f7d'), ('\u1f80', '\u1fb4'), ('\u1fb6',
+ '\u1fbc'), ('\u1fbe', '\u1fbe'), ('\u1fc2', '\u1fc4'), ('\u1fc6', '\u1fcc'), ('\u1fd0',
+ '\u1fd3'), ('\u1fd6', '\u1fdb'), ('\u1fe0', '\u1fec'), ('\u1ff2', '\u1ff4'), ('\u1ff6',
+ '\u1ffc'), ('\u2071', '\u2071'), ('\u207f', '\u207f'), ('\u2090', '\u209c'), ('\u2102',
+ '\u2102'), ('\u2107', '\u2107'), ('\u210a', '\u2113'), ('\u2115', '\u2115'), ('\u2119',
+ '\u211d'), ('\u2124', '\u2124'), ('\u2126', '\u2126'), ('\u2128', '\u2128'), ('\u212a',
+ '\u212d'), ('\u212f', '\u2134'), ('\u2135', '\u2138'), ('\u2139', '\u2139'), ('\u213c',
+ '\u213f'), ('\u2145', '\u2149'), ('\u214e', '\u214e'), ('\u2160', '\u2182'), ('\u2183',
+ '\u2184'), ('\u2185', '\u2188'), ('\u24b6', '\u24e9'), ('\u2c00', '\u2c2e'), ('\u2c30',
+ '\u2c5e'), ('\u2c60', '\u2c7b'), ('\u2c7c', '\u2c7d'), ('\u2c7e', '\u2ce4'), ('\u2ceb',
+ '\u2cee'), ('\u2cf2', '\u2cf3'), ('\u2d00', '\u2d25'), ('\u2d27', '\u2d27'), ('\u2d2d',
+ '\u2d2d'), ('\u2d30', '\u2d67'), ('\u2d6f', '\u2d6f'), ('\u2d80', '\u2d96'), ('\u2da0',
+ '\u2da6'), ('\u2da8', '\u2dae'), ('\u2db0', '\u2db6'), ('\u2db8', '\u2dbe'), ('\u2dc0',
+ '\u2dc6'), ('\u2dc8', '\u2dce'), ('\u2dd0', '\u2dd6'), ('\u2dd8', '\u2dde'), ('\u2de0',
+ '\u2dff'), ('\u2e2f', '\u2e2f'), ('\u3005', '\u3005'), ('\u3006', '\u3006'), ('\u3007',
+ '\u3007'), ('\u3021', '\u3029'), ('\u3031', '\u3035'), ('\u3038', '\u303a'), ('\u303b',
+ '\u303b'), ('\u303c', '\u303c'), ('\u3041', '\u3096'), ('\u309d', '\u309e'), ('\u309f',
+ '\u309f'), ('\u30a1', '\u30fa'), ('\u30fc', '\u30fe'), ('\u30ff', '\u30ff'), ('\u3105',
+ '\u312d'), ('\u3131', '\u318e'), ('\u31a0', '\u31ba'), ('\u31f0', '\u31ff'), ('\u3400',
+ '\u4db5'), ('\u4e00', '\u9fcc'), ('\ua000', '\ua014'), ('\ua015', '\ua015'), ('\ua016',
+ '\ua48c'), ('\ua4d0', '\ua4f7'), ('\ua4f8', '\ua4fd'), ('\ua500', '\ua60b'), ('\ua60c',
+ '\ua60c'), ('\ua610', '\ua61f'), ('\ua62a', '\ua62b'), ('\ua640', '\ua66d'), ('\ua66e',
+ '\ua66e'), ('\ua674', '\ua67b'), ('\ua67f', '\ua67f'), ('\ua680', '\ua69b'), ('\ua69c',
+ '\ua69d'), ('\ua69f', '\ua69f'), ('\ua6a0', '\ua6e5'), ('\ua6e6', '\ua6ef'), ('\ua717',
+ '\ua71f'), ('\ua722', '\ua76f'), ('\ua770', '\ua770'), ('\ua771', '\ua787'), ('\ua788',
+ '\ua788'), ('\ua78b', '\ua78e'), ('\ua790', '\ua7ad'), ('\ua7b0', '\ua7b1'), ('\ua7f7',
+ '\ua7f7'), ('\ua7f8', '\ua7f9'), ('\ua7fa', '\ua7fa'), ('\ua7fb', '\ua801'), ('\ua803',
+ '\ua805'), ('\ua807', '\ua80a'), ('\ua80c', '\ua822'), ('\ua823', '\ua824'), ('\ua825',
+ '\ua826'), ('\ua827', '\ua827'), ('\ua840', '\ua873'), ('\ua880', '\ua881'), ('\ua882',
+ '\ua8b3'), ('\ua8b4', '\ua8c3'), ('\ua8f2', '\ua8f7'), ('\ua8fb', '\ua8fb'), ('\ua90a',
+ '\ua925'), ('\ua926', '\ua92a'), ('\ua930', '\ua946'), ('\ua947', '\ua951'), ('\ua952',
+ '\ua952'), ('\ua960', '\ua97c'), ('\ua980', '\ua982'), ('\ua983', '\ua983'), ('\ua984',
+ '\ua9b2'), ('\ua9b4', '\ua9b5'), ('\ua9b6', '\ua9b9'), ('\ua9ba', '\ua9bb'), ('\ua9bc',
+ '\ua9bc'), ('\ua9bd', '\ua9bf'), ('\ua9cf', '\ua9cf'), ('\ua9e0', '\ua9e4'), ('\ua9e6',
+ '\ua9e6'), ('\ua9e7', '\ua9ef'), ('\ua9fa', '\ua9fe'), ('\uaa00', '\uaa28'), ('\uaa29',
+ '\uaa2e'), ('\uaa2f', '\uaa30'), ('\uaa31', '\uaa32'), ('\uaa33', '\uaa34'), ('\uaa35',
+ '\uaa36'), ('\uaa40', '\uaa42'), ('\uaa43', '\uaa43'), ('\uaa44', '\uaa4b'), ('\uaa4c',
+ '\uaa4c'), ('\uaa4d', '\uaa4d'), ('\uaa60', '\uaa6f'), ('\uaa70', '\uaa70'), ('\uaa71',
+ '\uaa76'), ('\uaa7a', '\uaa7a'), ('\uaa7e', '\uaaaf'), ('\uaab0', '\uaab0'), ('\uaab1',
+ '\uaab1'), ('\uaab2', '\uaab4'), ('\uaab5', '\uaab6'), ('\uaab7', '\uaab8'), ('\uaab9',
+ '\uaabd'), ('\uaabe', '\uaabe'), ('\uaac0', '\uaac0'), ('\uaac2', '\uaac2'), ('\uaadb',
+ '\uaadc'), ('\uaadd', '\uaadd'), ('\uaae0', '\uaaea'), ('\uaaeb', '\uaaeb'), ('\uaaec',
+ '\uaaed'), ('\uaaee', '\uaaef'), ('\uaaf2', '\uaaf2'), ('\uaaf3', '\uaaf4'), ('\uaaf5',
+ '\uaaf5'), ('\uab01', '\uab06'), ('\uab09', '\uab0e'), ('\uab11', '\uab16'), ('\uab20',
+ '\uab26'), ('\uab28', '\uab2e'), ('\uab30', '\uab5a'), ('\uab5c', '\uab5f'), ('\uab64',
+ '\uab65'), ('\uabc0', '\uabe2'), ('\uabe3', '\uabe4'), ('\uabe5', '\uabe5'), ('\uabe6',
+ '\uabe7'), ('\uabe8', '\uabe8'), ('\uabe9', '\uabea'), ('\uac00', '\ud7a3'), ('\ud7b0',
+ '\ud7c6'), ('\ud7cb', '\ud7fb'), ('\uf900', '\ufa6d'), ('\ufa70', '\ufad9'), ('\ufb00',
+ '\ufb06'), ('\ufb13', '\ufb17'), ('\ufb1d', '\ufb1d'), ('\ufb1e', '\ufb1e'), ('\ufb1f',
+ '\ufb28'), ('\ufb2a', '\ufb36'), ('\ufb38', '\ufb3c'), ('\ufb3e', '\ufb3e'), ('\ufb40',
+ '\ufb41'), ('\ufb43', '\ufb44'), ('\ufb46', '\ufbb1'), ('\ufbd3', '\ufd3d'), ('\ufd50',
+ '\ufd8f'), ('\ufd92', '\ufdc7'), ('\ufdf0', '\ufdfb'), ('\ufe70', '\ufe74'), ('\ufe76',
+ '\ufefc'), ('\uff21', '\uff3a'), ('\uff41', '\uff5a'), ('\uff66', '\uff6f'), ('\uff70',
+ '\uff70'), ('\uff71', '\uff9d'), ('\uff9e', '\uff9f'), ('\uffa0', '\uffbe'), ('\uffc2',
+ '\uffc7'), ('\uffca', '\uffcf'), ('\uffd2', '\uffd7'), ('\uffda', '\uffdc'), ('\U00010000',
+ '\U0001000b'), ('\U0001000d', '\U00010026'), ('\U00010028', '\U0001003a'), ('\U0001003c',
+ '\U0001003d'), ('\U0001003f', '\U0001004d'), ('\U00010050', '\U0001005d'), ('\U00010080',
+ '\U000100fa'), ('\U00010140', '\U00010174'), ('\U00010280', '\U0001029c'), ('\U000102a0',
+ '\U000102d0'), ('\U00010300', '\U0001031f'), ('\U00010330', '\U00010340'), ('\U00010341',
+ '\U00010341'), ('\U00010342', '\U00010349'), ('\U0001034a', '\U0001034a'), ('\U00010350',
+ '\U00010375'), ('\U00010376', '\U0001037a'), ('\U00010380', '\U0001039d'), ('\U000103a0',
+ '\U000103c3'), ('\U000103c8', '\U000103cf'), ('\U000103d1', '\U000103d5'), ('\U00010400',
+ '\U0001044f'), ('\U00010450', '\U0001049d'), ('\U00010500', '\U00010527'), ('\U00010530',
+ '\U00010563'), ('\U00010600', '\U00010736'), ('\U00010740', '\U00010755'), ('\U00010760',
+ '\U00010767'), ('\U00010800', '\U00010805'), ('\U00010808', '\U00010808'), ('\U0001080a',
+ '\U00010835'), ('\U00010837', '\U00010838'), ('\U0001083c', '\U0001083c'), ('\U0001083f',
+ '\U00010855'), ('\U00010860', '\U00010876'), ('\U00010880', '\U0001089e'), ('\U00010900',
+ '\U00010915'), ('\U00010920', '\U00010939'), ('\U00010980', '\U000109b7'), ('\U000109be',
+ '\U000109bf'), ('\U00010a00', '\U00010a00'), ('\U00010a01', '\U00010a03'), ('\U00010a05',
+ '\U00010a06'), ('\U00010a0c', '\U00010a0f'), ('\U00010a10', '\U00010a13'), ('\U00010a15',
+ '\U00010a17'), ('\U00010a19', '\U00010a33'), ('\U00010a60', '\U00010a7c'), ('\U00010a80',
+ '\U00010a9c'), ('\U00010ac0', '\U00010ac7'), ('\U00010ac9', '\U00010ae4'), ('\U00010b00',
+ '\U00010b35'), ('\U00010b40', '\U00010b55'), ('\U00010b60', '\U00010b72'), ('\U00010b80',
+ '\U00010b91'), ('\U00010c00', '\U00010c48'), ('\U00011000', '\U00011000'), ('\U00011001',
+ '\U00011001'), ('\U00011002', '\U00011002'), ('\U00011003', '\U00011037'), ('\U00011038',
+ '\U00011045'), ('\U00011082', '\U00011082'), ('\U00011083', '\U000110af'), ('\U000110b0',
+ '\U000110b2'), ('\U000110b3', '\U000110b6'), ('\U000110b7', '\U000110b8'), ('\U000110d0',
+ '\U000110e8'), ('\U00011100', '\U00011102'), ('\U00011103', '\U00011126'), ('\U00011127',
+ '\U0001112b'), ('\U0001112c', '\U0001112c'), ('\U0001112d', '\U00011132'), ('\U00011150',
+ '\U00011172'), ('\U00011176', '\U00011176'), ('\U00011180', '\U00011181'), ('\U00011182',
+ '\U00011182'), ('\U00011183', '\U000111b2'), ('\U000111b3', '\U000111b5'), ('\U000111b6',
+ '\U000111be'), ('\U000111bf', '\U000111bf'), ('\U000111c1', '\U000111c4'), ('\U000111da',
+ '\U000111da'), ('\U00011200', '\U00011211'), ('\U00011213', '\U0001122b'), ('\U0001122c',
+ '\U0001122e'), ('\U0001122f', '\U00011231'), ('\U00011232', '\U00011233'), ('\U00011234',
+ '\U00011234'), ('\U00011237', '\U00011237'), ('\U000112b0', '\U000112de'), ('\U000112df',
+ '\U000112df'), ('\U000112e0', '\U000112e2'), ('\U000112e3', '\U000112e8'), ('\U00011301',
+ '\U00011301'), ('\U00011302', '\U00011303'), ('\U00011305', '\U0001130c'), ('\U0001130f',
+ '\U00011310'), ('\U00011313', '\U00011328'), ('\U0001132a', '\U00011330'), ('\U00011332',
+ '\U00011333'), ('\U00011335', '\U00011339'), ('\U0001133d', '\U0001133d'), ('\U0001133e',
+ '\U0001133f'), ('\U00011340', '\U00011340'), ('\U00011341', '\U00011344'), ('\U00011347',
+ '\U00011348'), ('\U0001134b', '\U0001134c'), ('\U00011357', '\U00011357'), ('\U0001135d',
+ '\U00011361'), ('\U00011362', '\U00011363'), ('\U00011480', '\U000114af'), ('\U000114b0',
+ '\U000114b2'), ('\U000114b3', '\U000114b8'), ('\U000114b9', '\U000114b9'), ('\U000114ba',
+ '\U000114ba'), ('\U000114bb', '\U000114be'), ('\U000114bf', '\U000114c0'), ('\U000114c1',
+ '\U000114c1'), ('\U000114c4', '\U000114c5'), ('\U000114c7', '\U000114c7'), ('\U00011580',
+ '\U000115ae'), ('\U000115af', '\U000115b1'), ('\U000115b2', '\U000115b5'), ('\U000115b8',
+ '\U000115bb'), ('\U000115bc', '\U000115bd'), ('\U000115be', '\U000115be'), ('\U00011600',
+ '\U0001162f'), ('\U00011630', '\U00011632'), ('\U00011633', '\U0001163a'), ('\U0001163b',
+ '\U0001163c'), ('\U0001163d', '\U0001163d'), ('\U0001163e', '\U0001163e'), ('\U00011640',
+ '\U00011640'), ('\U00011644', '\U00011644'), ('\U00011680', '\U000116aa'), ('\U000116ab',
+ '\U000116ab'), ('\U000116ac', '\U000116ac'), ('\U000116ad', '\U000116ad'), ('\U000116ae',
+ '\U000116af'), ('\U000116b0', '\U000116b5'), ('\U000118a0', '\U000118df'), ('\U000118ff',
+ '\U000118ff'), ('\U00011ac0', '\U00011af8'), ('\U00012000', '\U00012398'), ('\U00012400',
+ '\U0001246e'), ('\U00013000', '\U0001342e'), ('\U00016800', '\U00016a38'), ('\U00016a40',
+ '\U00016a5e'), ('\U00016ad0', '\U00016aed'), ('\U00016b00', '\U00016b2f'), ('\U00016b30',
+ '\U00016b36'), ('\U00016b40', '\U00016b43'), ('\U00016b63', '\U00016b77'), ('\U00016b7d',
+ '\U00016b8f'), ('\U00016f00', '\U00016f44'), ('\U00016f50', '\U00016f50'), ('\U00016f51',
+ '\U00016f7e'), ('\U00016f93', '\U00016f9f'), ('\U0001b000', '\U0001b001'), ('\U0001bc00',
+ '\U0001bc6a'), ('\U0001bc70', '\U0001bc7c'), ('\U0001bc80', '\U0001bc88'), ('\U0001bc90',
+ '\U0001bc99'), ('\U0001bc9e', '\U0001bc9e'), ('\U0001d400', '\U0001d454'), ('\U0001d456',
+ '\U0001d49c'), ('\U0001d49e', '\U0001d49f'), ('\U0001d4a2', '\U0001d4a2'), ('\U0001d4a5',
+ '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'), ('\U0001d4ae', '\U0001d4b9'), ('\U0001d4bb',
+ '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5', '\U0001d505'), ('\U0001d507',
+ '\U0001d50a'), ('\U0001d50d', '\U0001d514'), ('\U0001d516', '\U0001d51c'), ('\U0001d51e',
+ '\U0001d539'), ('\U0001d53b', '\U0001d53e'), ('\U0001d540', '\U0001d544'), ('\U0001d546',
+ '\U0001d546'), ('\U0001d54a', '\U0001d550'), ('\U0001d552', '\U0001d6a5'), ('\U0001d6a8',
+ '\U0001d6c0'), ('\U0001d6c2', '\U0001d6da'), ('\U0001d6dc', '\U0001d6fa'), ('\U0001d6fc',
+ '\U0001d714'), ('\U0001d716', '\U0001d734'), ('\U0001d736', '\U0001d74e'), ('\U0001d750',
+ '\U0001d76e'), ('\U0001d770', '\U0001d788'), ('\U0001d78a', '\U0001d7a8'), ('\U0001d7aa',
+ '\U0001d7c2'), ('\U0001d7c4', '\U0001d7cb'), ('\U0001e800', '\U0001e8c4'), ('\U0001ee00',
+ '\U0001ee03'), ('\U0001ee05', '\U0001ee1f'), ('\U0001ee21', '\U0001ee22'), ('\U0001ee24',
+ '\U0001ee24'), ('\U0001ee27', '\U0001ee27'), ('\U0001ee29', '\U0001ee32'), ('\U0001ee34',
+ '\U0001ee37'), ('\U0001ee39', '\U0001ee39'), ('\U0001ee3b', '\U0001ee3b'), ('\U0001ee42',
+ '\U0001ee42'), ('\U0001ee47', '\U0001ee47'), ('\U0001ee49', '\U0001ee49'), ('\U0001ee4b',
+ '\U0001ee4b'), ('\U0001ee4d', '\U0001ee4f'), ('\U0001ee51', '\U0001ee52'), ('\U0001ee54',
+ '\U0001ee54'), ('\U0001ee57', '\U0001ee57'), ('\U0001ee59', '\U0001ee59'), ('\U0001ee5b',
+ '\U0001ee5b'), ('\U0001ee5d', '\U0001ee5d'), ('\U0001ee5f', '\U0001ee5f'), ('\U0001ee61',
+ '\U0001ee62'), ('\U0001ee64', '\U0001ee64'), ('\U0001ee67', '\U0001ee6a'), ('\U0001ee6c',
+ '\U0001ee72'), ('\U0001ee74', '\U0001ee77'), ('\U0001ee79', '\U0001ee7c'), ('\U0001ee7e',
+ '\U0001ee7e'), ('\U0001ee80', '\U0001ee89'), ('\U0001ee8b', '\U0001ee9b'), ('\U0001eea1',
+ '\U0001eea3'), ('\U0001eea5', '\U0001eea9'), ('\U0001eeab', '\U0001eebb'), ('\U0001f130',
+ '\U0001f149'), ('\U0001f150', '\U0001f169'), ('\U0001f170', '\U0001f189'), ('\U00020000',
+ '\U0002a6d6'), ('\U0002a700', '\U0002b734'), ('\U0002b740', '\U0002b81d'), ('\U0002f800',
+ '\U0002fa1d')
+ ];
+
+ pub fn Alphabetic(c: char) -> bool {
+ super::bsearch_range_table(c, Alphabetic_table)
+ }
+
+ pub static Lowercase_table: &'static [(char, char)] = &[
+ ('\x61', '\x7a'), ('\xaa', '\xaa'), ('\xb5', '\xb5'), ('\xba', '\xba'), ('\xdf', '\xf6'),
+ ('\xf8', '\xff'), ('\u0101', '\u0101'), ('\u0103', '\u0103'), ('\u0105', '\u0105'),
+ ('\u0107', '\u0107'), ('\u0109', '\u0109'), ('\u010b', '\u010b'), ('\u010d', '\u010d'),
+ ('\u010f', '\u010f'), ('\u0111', '\u0111'), ('\u0113', '\u0113'), ('\u0115', '\u0115'),
+ ('\u0117', '\u0117'), ('\u0119', '\u0119'), ('\u011b', '\u011b'), ('\u011d', '\u011d'),
+ ('\u011f', '\u011f'), ('\u0121', '\u0121'), ('\u0123', '\u0123'), ('\u0125', '\u0125'),
+ ('\u0127', '\u0127'), ('\u0129', '\u0129'), ('\u012b', '\u012b'), ('\u012d', '\u012d'),
+ ('\u012f', '\u012f'), ('\u0131', '\u0131'), ('\u0133', '\u0133'), ('\u0135', '\u0135'),
+ ('\u0137', '\u0138'), ('\u013a', '\u013a'), ('\u013c', '\u013c'), ('\u013e', '\u013e'),
+ ('\u0140', '\u0140'), ('\u0142', '\u0142'), ('\u0144', '\u0144'), ('\u0146', '\u0146'),
+ ('\u0148', '\u0149'), ('\u014b', '\u014b'), ('\u014d', '\u014d'), ('\u014f', '\u014f'),
+ ('\u0151', '\u0151'), ('\u0153', '\u0153'), ('\u0155', '\u0155'), ('\u0157', '\u0157'),
+ ('\u0159', '\u0159'), ('\u015b', '\u015b'), ('\u015d', '\u015d'), ('\u015f', '\u015f'),
+ ('\u0161', '\u0161'), ('\u0163', '\u0163'), ('\u0165', '\u0165'), ('\u0167', '\u0167'),
+ ('\u0169', '\u0169'), ('\u016b', '\u016b'), ('\u016d', '\u016d'), ('\u016f', '\u016f'),
+ ('\u0171', '\u0171'), ('\u0173', '\u0173'), ('\u0175', '\u0175'), ('\u0177', '\u0177'),
+ ('\u017a', '\u017a'), ('\u017c', '\u017c'), ('\u017e', '\u0180'), ('\u0183', '\u0183'),
+ ('\u0185', '\u0185'), ('\u0188', '\u0188'), ('\u018c', '\u018d'), ('\u0192', '\u0192'),
+ ('\u0195', '\u0195'), ('\u0199', '\u019b'), ('\u019e', '\u019e'), ('\u01a1', '\u01a1'),
+ ('\u01a3', '\u01a3'), ('\u01a5', '\u01a5'), ('\u01a8', '\u01a8'), ('\u01aa', '\u01ab'),
+ ('\u01ad', '\u01ad'), ('\u01b0', '\u01b0'), ('\u01b4', '\u01b4'), ('\u01b6', '\u01b6'),
+ ('\u01b9', '\u01ba'), ('\u01bd', '\u01bf'), ('\u01c6', '\u01c6'), ('\u01c9', '\u01c9'),
+ ('\u01cc', '\u01cc'), ('\u01ce', '\u01ce'), ('\u01d0', '\u01d0'), ('\u01d2', '\u01d2'),
+ ('\u01d4', '\u01d4'), ('\u01d6', '\u01d6'), ('\u01d8', '\u01d8'), ('\u01da', '\u01da'),
+ ('\u01dc', '\u01dd'), ('\u01df', '\u01df'), ('\u01e1', '\u01e1'), ('\u01e3', '\u01e3'),
+ ('\u01e5', '\u01e5'), ('\u01e7', '\u01e7'), ('\u01e9', '\u01e9'), ('\u01eb', '\u01eb'),
+ ('\u01ed', '\u01ed'), ('\u01ef', '\u01f0'), ('\u01f3', '\u01f3'), ('\u01f5', '\u01f5'),
+ ('\u01f9', '\u01f9'), ('\u01fb', '\u01fb'), ('\u01fd', '\u01fd'), ('\u01ff', '\u01ff'),
+ ('\u0201', '\u0201'), ('\u0203', '\u0203'), ('\u0205', '\u0205'), ('\u0207', '\u0207'),
+ ('\u0209', '\u0209'), ('\u020b', '\u020b'), ('\u020d', '\u020d'), ('\u020f', '\u020f'),
+ ('\u0211', '\u0211'), ('\u0213', '\u0213'), ('\u0215', '\u0215'), ('\u0217', '\u0217'),
+ ('\u0219', '\u0219'), ('\u021b', '\u021b'), ('\u021d', '\u021d'), ('\u021f', '\u021f'),
+ ('\u0221', '\u0221'), ('\u0223', '\u0223'), ('\u0225', '\u0225'), ('\u0227', '\u0227'),
+ ('\u0229', '\u0229'), ('\u022b', '\u022b'), ('\u022d', '\u022d'), ('\u022f', '\u022f'),
+ ('\u0231', '\u0231'), ('\u0233', '\u0239'), ('\u023c', '\u023c'), ('\u023f', '\u0240'),
+ ('\u0242', '\u0242'), ('\u0247', '\u0247'), ('\u0249', '\u0249'), ('\u024b', '\u024b'),
+ ('\u024d', '\u024d'), ('\u024f', '\u0293'), ('\u0295', '\u02af'), ('\u02b0', '\u02b8'),
+ ('\u02c0', '\u02c1'), ('\u02e0', '\u02e4'), ('\u0345', '\u0345'), ('\u0371', '\u0371'),
+ ('\u0373', '\u0373'), ('\u0377', '\u0377'), ('\u037a', '\u037a'), ('\u037b', '\u037d'),
+ ('\u0390', '\u0390'), ('\u03ac', '\u03ce'), ('\u03d0', '\u03d1'), ('\u03d5', '\u03d7'),
+ ('\u03d9', '\u03d9'), ('\u03db', '\u03db'), ('\u03dd', '\u03dd'), ('\u03df', '\u03df'),
+ ('\u03e1', '\u03e1'), ('\u03e3', '\u03e3'), ('\u03e5', '\u03e5'), ('\u03e7', '\u03e7'),
+ ('\u03e9', '\u03e9'), ('\u03eb', '\u03eb'), ('\u03ed', '\u03ed'), ('\u03ef', '\u03f3'),
+ ('\u03f5', '\u03f5'), ('\u03f8', '\u03f8'), ('\u03fb', '\u03fc'), ('\u0430', '\u045f'),
+ ('\u0461', '\u0461'), ('\u0463', '\u0463'), ('\u0465', '\u0465'), ('\u0467', '\u0467'),
+ ('\u0469', '\u0469'), ('\u046b', '\u046b'), ('\u046d', '\u046d'), ('\u046f', '\u046f'),
+ ('\u0471', '\u0471'), ('\u0473', '\u0473'), ('\u0475', '\u0475'), ('\u0477', '\u0477'),
+ ('\u0479', '\u0479'), ('\u047b', '\u047b'), ('\u047d', '\u047d'), ('\u047f', '\u047f'),
+ ('\u0481', '\u0481'), ('\u048b', '\u048b'), ('\u048d', '\u048d'), ('\u048f', '\u048f'),
+ ('\u0491', '\u0491'), ('\u0493', '\u0493'), ('\u0495', '\u0495'), ('\u0497', '\u0497'),
+ ('\u0499', '\u0499'), ('\u049b', '\u049b'), ('\u049d', '\u049d'), ('\u049f', '\u049f'),
+ ('\u04a1', '\u04a1'), ('\u04a3', '\u04a3'), ('\u04a5', '\u04a5'), ('\u04a7', '\u04a7'),
+ ('\u04a9', '\u04a9'), ('\u04ab', '\u04ab'), ('\u04ad', '\u04ad'), ('\u04af', '\u04af'),
+ ('\u04b1', '\u04b1'), ('\u04b3', '\u04b3'), ('\u04b5', '\u04b5'), ('\u04b7', '\u04b7'),
+ ('\u04b9', '\u04b9'), ('\u04bb', '\u04bb'), ('\u04bd', '\u04bd'), ('\u04bf', '\u04bf'),
+ ('\u04c2', '\u04c2'), ('\u04c4', '\u04c4'), ('\u04c6', '\u04c6'), ('\u04c8', '\u04c8'),
+ ('\u04ca', '\u04ca'), ('\u04cc', '\u04cc'), ('\u04ce', '\u04cf'), ('\u04d1', '\u04d1'),
+ ('\u04d3', '\u04d3'), ('\u04d5', '\u04d5'), ('\u04d7', '\u04d7'), ('\u04d9', '\u04d9'),
+ ('\u04db', '\u04db'), ('\u04dd', '\u04dd'), ('\u04df', '\u04df'), ('\u04e1', '\u04e1'),
+ ('\u04e3', '\u04e3'), ('\u04e5', '\u04e5'), ('\u04e7', '\u04e7'), ('\u04e9', '\u04e9'),
+ ('\u04eb', '\u04eb'), ('\u04ed', '\u04ed'), ('\u04ef', '\u04ef'), ('\u04f1', '\u04f1'),
+ ('\u04f3', '\u04f3'), ('\u04f5', '\u04f5'), ('\u04f7', '\u04f7'), ('\u04f9', '\u04f9'),
+ ('\u04fb', '\u04fb'), ('\u04fd', '\u04fd'), ('\u04ff', '\u04ff'), ('\u0501', '\u0501'),
+ ('\u0503', '\u0503'), ('\u0505', '\u0505'), ('\u0507', '\u0507'), ('\u0509', '\u0509'),
+ ('\u050b', '\u050b'), ('\u050d', '\u050d'), ('\u050f', '\u050f'), ('\u0511', '\u0511'),
+ ('\u0513', '\u0513'), ('\u0515', '\u0515'), ('\u0517', '\u0517'), ('\u0519', '\u0519'),
+ ('\u051b', '\u051b'), ('\u051d', '\u051d'), ('\u051f', '\u051f'), ('\u0521', '\u0521'),
+ ('\u0523', '\u0523'), ('\u0525', '\u0525'), ('\u0527', '\u0527'), ('\u0529', '\u0529'),
+ ('\u052b', '\u052b'), ('\u052d', '\u052d'), ('\u052f', '\u052f'), ('\u0561', '\u0587'),
+ ('\u1d00', '\u1d2b'), ('\u1d2c', '\u1d6a'), ('\u1d6b', '\u1d77'), ('\u1d78', '\u1d78'),
+ ('\u1d79', '\u1d9a'), ('\u1d9b', '\u1dbf'), ('\u1e01', '\u1e01'), ('\u1e03', '\u1e03'),
+ ('\u1e05', '\u1e05'), ('\u1e07', '\u1e07'), ('\u1e09', '\u1e09'), ('\u1e0b', '\u1e0b'),
+ ('\u1e0d', '\u1e0d'), ('\u1e0f', '\u1e0f'), ('\u1e11', '\u1e11'), ('\u1e13', '\u1e13'),
+ ('\u1e15', '\u1e15'), ('\u1e17', '\u1e17'), ('\u1e19', '\u1e19'), ('\u1e1b', '\u1e1b'),
+ ('\u1e1d', '\u1e1d'), ('\u1e1f', '\u1e1f'), ('\u1e21', '\u1e21'), ('\u1e23', '\u1e23'),
+ ('\u1e25', '\u1e25'), ('\u1e27', '\u1e27'), ('\u1e29', '\u1e29'), ('\u1e2b', '\u1e2b'),
+ ('\u1e2d', '\u1e2d'), ('\u1e2f', '\u1e2f'), ('\u1e31', '\u1e31'), ('\u1e33', '\u1e33'),
+ ('\u1e35', '\u1e35'), ('\u1e37', '\u1e37'), ('\u1e39', '\u1e39'), ('\u1e3b', '\u1e3b'),
+ ('\u1e3d', '\u1e3d'), ('\u1e3f', '\u1e3f'), ('\u1e41', '\u1e41'), ('\u1e43', '\u1e43'),
+ ('\u1e45', '\u1e45'), ('\u1e47', '\u1e47'), ('\u1e49', '\u1e49'), ('\u1e4b', '\u1e4b'),
+ ('\u1e4d', '\u1e4d'), ('\u1e4f', '\u1e4f'), ('\u1e51', '\u1e51'), ('\u1e53', '\u1e53'),
+ ('\u1e55', '\u1e55'), ('\u1e57', '\u1e57'), ('\u1e59', '\u1e59'), ('\u1e5b', '\u1e5b'),
+ ('\u1e5d', '\u1e5d'), ('\u1e5f', '\u1e5f'), ('\u1e61', '\u1e61'), ('\u1e63', '\u1e63'),
+ ('\u1e65', '\u1e65'), ('\u1e67', '\u1e67'), ('\u1e69', '\u1e69'), ('\u1e6b', '\u1e6b'),
+ ('\u1e6d', '\u1e6d'), ('\u1e6f', '\u1e6f'), ('\u1e71', '\u1e71'), ('\u1e73', '\u1e73'),
+ ('\u1e75', '\u1e75'), ('\u1e77', '\u1e77'), ('\u1e79', '\u1e79'), ('\u1e7b', '\u1e7b'),
+ ('\u1e7d', '\u1e7d'), ('\u1e7f', '\u1e7f'), ('\u1e81', '\u1e81'), ('\u1e83', '\u1e83'),
+ ('\u1e85', '\u1e85'), ('\u1e87', '\u1e87'), ('\u1e89', '\u1e89'), ('\u1e8b', '\u1e8b'),
+ ('\u1e8d', '\u1e8d'), ('\u1e8f', '\u1e8f'), ('\u1e91', '\u1e91'), ('\u1e93', '\u1e93'),
+ ('\u1e95', '\u1e9d'), ('\u1e9f', '\u1e9f'), ('\u1ea1', '\u1ea1'), ('\u1ea3', '\u1ea3'),
+ ('\u1ea5', '\u1ea5'), ('\u1ea7', '\u1ea7'), ('\u1ea9', '\u1ea9'), ('\u1eab', '\u1eab'),
+ ('\u1ead', '\u1ead'), ('\u1eaf', '\u1eaf'), ('\u1eb1', '\u1eb1'), ('\u1eb3', '\u1eb3'),
+ ('\u1eb5', '\u1eb5'), ('\u1eb7', '\u1eb7'), ('\u1eb9', '\u1eb9'), ('\u1ebb', '\u1ebb'),
+ ('\u1ebd', '\u1ebd'), ('\u1ebf', '\u1ebf'), ('\u1ec1', '\u1ec1'), ('\u1ec3', '\u1ec3'),
+ ('\u1ec5', '\u1ec5'), ('\u1ec7', '\u1ec7'), ('\u1ec9', '\u1ec9'), ('\u1ecb', '\u1ecb'),
+ ('\u1ecd', '\u1ecd'), ('\u1ecf', '\u1ecf'), ('\u1ed1', '\u1ed1'), ('\u1ed3', '\u1ed3'),
+ ('\u1ed5', '\u1ed5'), ('\u1ed7', '\u1ed7'), ('\u1ed9', '\u1ed9'), ('\u1edb', '\u1edb'),
+ ('\u1edd', '\u1edd'), ('\u1edf', '\u1edf'), ('\u1ee1', '\u1ee1'), ('\u1ee3', '\u1ee3'),
+ ('\u1ee5', '\u1ee5'), ('\u1ee7', '\u1ee7'), ('\u1ee9', '\u1ee9'), ('\u1eeb', '\u1eeb'),
+ ('\u1eed', '\u1eed'), ('\u1eef', '\u1eef'), ('\u1ef1', '\u1ef1'), ('\u1ef3', '\u1ef3'),
+ ('\u1ef5', '\u1ef5'), ('\u1ef7', '\u1ef7'), ('\u1ef9', '\u1ef9'), ('\u1efb', '\u1efb'),
+ ('\u1efd', '\u1efd'), ('\u1eff', '\u1f07'), ('\u1f10', '\u1f15'), ('\u1f20', '\u1f27'),
+ ('\u1f30', '\u1f37'), ('\u1f40', '\u1f45'), ('\u1f50', '\u1f57'), ('\u1f60', '\u1f67'),
+ ('\u1f70', '\u1f7d'), ('\u1f80', '\u1f87'), ('\u1f90', '\u1f97'), ('\u1fa0', '\u1fa7'),
+ ('\u1fb0', '\u1fb4'), ('\u1fb6', '\u1fb7'), ('\u1fbe', '\u1fbe'), ('\u1fc2', '\u1fc4'),
+ ('\u1fc6', '\u1fc7'), ('\u1fd0', '\u1fd3'), ('\u1fd6', '\u1fd7'), ('\u1fe0', '\u1fe7'),
+ ('\u1ff2', '\u1ff4'), ('\u1ff6', '\u1ff7'), ('\u2071', '\u2071'), ('\u207f', '\u207f'),
+ ('\u2090', '\u209c'), ('\u210a', '\u210a'), ('\u210e', '\u210f'), ('\u2113', '\u2113'),
+ ('\u212f', '\u212f'), ('\u2134', '\u2134'), ('\u2139', '\u2139'), ('\u213c', '\u213d'),
+ ('\u2146', '\u2149'), ('\u214e', '\u214e'), ('\u2170', '\u217f'), ('\u2184', '\u2184'),
+ ('\u24d0', '\u24e9'), ('\u2c30', '\u2c5e'), ('\u2c61', '\u2c61'), ('\u2c65', '\u2c66'),
+ ('\u2c68', '\u2c68'), ('\u2c6a', '\u2c6a'), ('\u2c6c', '\u2c6c'), ('\u2c71', '\u2c71'),
+ ('\u2c73', '\u2c74'), ('\u2c76', '\u2c7b'), ('\u2c7c', '\u2c7d'), ('\u2c81', '\u2c81'),
+ ('\u2c83', '\u2c83'), ('\u2c85', '\u2c85'), ('\u2c87', '\u2c87'), ('\u2c89', '\u2c89'),
+ ('\u2c8b', '\u2c8b'), ('\u2c8d', '\u2c8d'), ('\u2c8f', '\u2c8f'), ('\u2c91', '\u2c91'),
+ ('\u2c93', '\u2c93'), ('\u2c95', '\u2c95'), ('\u2c97', '\u2c97'), ('\u2c99', '\u2c99'),
+ ('\u2c9b', '\u2c9b'), ('\u2c9d', '\u2c9d'), ('\u2c9f', '\u2c9f'), ('\u2ca1', '\u2ca1'),
+ ('\u2ca3', '\u2ca3'), ('\u2ca5', '\u2ca5'), ('\u2ca7', '\u2ca7'), ('\u2ca9', '\u2ca9'),
+ ('\u2cab', '\u2cab'), ('\u2cad', '\u2cad'), ('\u2caf', '\u2caf'), ('\u2cb1', '\u2cb1'),
+ ('\u2cb3', '\u2cb3'), ('\u2cb5', '\u2cb5'), ('\u2cb7', '\u2cb7'), ('\u2cb9', '\u2cb9'),
+ ('\u2cbb', '\u2cbb'), ('\u2cbd', '\u2cbd'), ('\u2cbf', '\u2cbf'), ('\u2cc1', '\u2cc1'),
+ ('\u2cc3', '\u2cc3'), ('\u2cc5', '\u2cc5'), ('\u2cc7', '\u2cc7'), ('\u2cc9', '\u2cc9'),
+ ('\u2ccb', '\u2ccb'), ('\u2ccd', '\u2ccd'), ('\u2ccf', '\u2ccf'), ('\u2cd1', '\u2cd1'),
+ ('\u2cd3', '\u2cd3'), ('\u2cd5', '\u2cd5'), ('\u2cd7', '\u2cd7'), ('\u2cd9', '\u2cd9'),
+ ('\u2cdb', '\u2cdb'), ('\u2cdd', '\u2cdd'), ('\u2cdf', '\u2cdf'), ('\u2ce1', '\u2ce1'),
+ ('\u2ce3', '\u2ce4'), ('\u2cec', '\u2cec'), ('\u2cee', '\u2cee'), ('\u2cf3', '\u2cf3'),
+ ('\u2d00', '\u2d25'), ('\u2d27', '\u2d27'), ('\u2d2d', '\u2d2d'), ('\ua641', '\ua641'),
+ ('\ua643', '\ua643'), ('\ua645', '\ua645'), ('\ua647', '\ua647'), ('\ua649', '\ua649'),
+ ('\ua64b', '\ua64b'), ('\ua64d', '\ua64d'), ('\ua64f', '\ua64f'), ('\ua651', '\ua651'),
+ ('\ua653', '\ua653'), ('\ua655', '\ua655'), ('\ua657', '\ua657'), ('\ua659', '\ua659'),
+ ('\ua65b', '\ua65b'), ('\ua65d', '\ua65d'), ('\ua65f', '\ua65f'), ('\ua661', '\ua661'),
+ ('\ua663', '\ua663'), ('\ua665', '\ua665'), ('\ua667', '\ua667'), ('\ua669', '\ua669'),
+ ('\ua66b', '\ua66b'), ('\ua66d', '\ua66d'), ('\ua681', '\ua681'), ('\ua683', '\ua683'),
+ ('\ua685', '\ua685'), ('\ua687', '\ua687'), ('\ua689', '\ua689'), ('\ua68b', '\ua68b'),
+ ('\ua68d', '\ua68d'), ('\ua68f', '\ua68f'), ('\ua691', '\ua691'), ('\ua693', '\ua693'),
+ ('\ua695', '\ua695'), ('\ua697', '\ua697'), ('\ua699', '\ua699'), ('\ua69b', '\ua69b'),
+ ('\ua69c', '\ua69d'), ('\ua723', '\ua723'), ('\ua725', '\ua725'), ('\ua727', '\ua727'),
+ ('\ua729', '\ua729'), ('\ua72b', '\ua72b'), ('\ua72d', '\ua72d'), ('\ua72f', '\ua731'),
+ ('\ua733', '\ua733'), ('\ua735', '\ua735'), ('\ua737', '\ua737'), ('\ua739', '\ua739'),
+ ('\ua73b', '\ua73b'), ('\ua73d', '\ua73d'), ('\ua73f', '\ua73f'), ('\ua741', '\ua741'),
+ ('\ua743', '\ua743'), ('\ua745', '\ua745'), ('\ua747', '\ua747'), ('\ua749', '\ua749'),
+ ('\ua74b', '\ua74b'), ('\ua74d', '\ua74d'), ('\ua74f', '\ua74f'), ('\ua751', '\ua751'),
+ ('\ua753', '\ua753'), ('\ua755', '\ua755'), ('\ua757', '\ua757'), ('\ua759', '\ua759'),
+ ('\ua75b', '\ua75b'), ('\ua75d', '\ua75d'), ('\ua75f', '\ua75f'), ('\ua761', '\ua761'),
+ ('\ua763', '\ua763'), ('\ua765', '\ua765'), ('\ua767', '\ua767'), ('\ua769', '\ua769'),
+ ('\ua76b', '\ua76b'), ('\ua76d', '\ua76d'), ('\ua76f', '\ua76f'), ('\ua770', '\ua770'),
+ ('\ua771', '\ua778'), ('\ua77a', '\ua77a'), ('\ua77c', '\ua77c'), ('\ua77f', '\ua77f'),
+ ('\ua781', '\ua781'), ('\ua783', '\ua783'), ('\ua785', '\ua785'), ('\ua787', '\ua787'),
+ ('\ua78c', '\ua78c'), ('\ua78e', '\ua78e'), ('\ua791', '\ua791'), ('\ua793', '\ua795'),
+ ('\ua797', '\ua797'), ('\ua799', '\ua799'), ('\ua79b', '\ua79b'), ('\ua79d', '\ua79d'),
+ ('\ua79f', '\ua79f'), ('\ua7a1', '\ua7a1'), ('\ua7a3', '\ua7a3'), ('\ua7a5', '\ua7a5'),
+ ('\ua7a7', '\ua7a7'), ('\ua7a9', '\ua7a9'), ('\ua7f8', '\ua7f9'), ('\ua7fa', '\ua7fa'),
+ ('\uab30', '\uab5a'), ('\uab5c', '\uab5f'), ('\uab64', '\uab65'), ('\ufb00', '\ufb06'),
+ ('\ufb13', '\ufb17'), ('\uff41', '\uff5a'), ('\U00010428', '\U0001044f'), ('\U000118c0',
+ '\U000118df'), ('\U0001d41a', '\U0001d433'), ('\U0001d44e', '\U0001d454'), ('\U0001d456',
+ '\U0001d467'), ('\U0001d482', '\U0001d49b'), ('\U0001d4b6', '\U0001d4b9'), ('\U0001d4bb',
+ '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5', '\U0001d4cf'), ('\U0001d4ea',
+ '\U0001d503'), ('\U0001d51e', '\U0001d537'), ('\U0001d552', '\U0001d56b'), ('\U0001d586',
+ '\U0001d59f'), ('\U0001d5ba', '\U0001d5d3'), ('\U0001d5ee', '\U0001d607'), ('\U0001d622',
+ '\U0001d63b'), ('\U0001d656', '\U0001d66f'), ('\U0001d68a', '\U0001d6a5'), ('\U0001d6c2',
+ '\U0001d6da'), ('\U0001d6dc', '\U0001d6e1'), ('\U0001d6fc', '\U0001d714'), ('\U0001d716',
+ '\U0001d71b'), ('\U0001d736', '\U0001d74e'), ('\U0001d750', '\U0001d755'), ('\U0001d770',
+ '\U0001d788'), ('\U0001d78a', '\U0001d78f'), ('\U0001d7aa', '\U0001d7c2'), ('\U0001d7c4',
+ '\U0001d7c9'), ('\U0001d7cb', '\U0001d7cb')
+ ];
+
+ pub fn Lowercase(c: char) -> bool {
+ super::bsearch_range_table(c, Lowercase_table)
+ }
+
+ pub static Uppercase_table: &'static [(char, char)] = &[
+ ('\x41', '\x5a'), ('\xc0', '\xd6'), ('\xd8', '\xde'), ('\u0100', '\u0100'), ('\u0102',
+ '\u0102'), ('\u0104', '\u0104'), ('\u0106', '\u0106'), ('\u0108', '\u0108'), ('\u010a',
+ '\u010a'), ('\u010c', '\u010c'), ('\u010e', '\u010e'), ('\u0110', '\u0110'), ('\u0112',
+ '\u0112'), ('\u0114', '\u0114'), ('\u0116', '\u0116'), ('\u0118', '\u0118'), ('\u011a',
+ '\u011a'), ('\u011c', '\u011c'), ('\u011e', '\u011e'), ('\u0120', '\u0120'), ('\u0122',
+ '\u0122'), ('\u0124', '\u0124'), ('\u0126', '\u0126'), ('\u0128', '\u0128'), ('\u012a',
+ '\u012a'), ('\u012c', '\u012c'), ('\u012e', '\u012e'), ('\u0130', '\u0130'), ('\u0132',
+ '\u0132'), ('\u0134', '\u0134'), ('\u0136', '\u0136'), ('\u0139', '\u0139'), ('\u013b',
+ '\u013b'), ('\u013d', '\u013d'), ('\u013f', '\u013f'), ('\u0141', '\u0141'), ('\u0143',
+ '\u0143'), ('\u0145', '\u0145'), ('\u0147', '\u0147'), ('\u014a', '\u014a'), ('\u014c',
+ '\u014c'), ('\u014e', '\u014e'), ('\u0150', '\u0150'), ('\u0152', '\u0152'), ('\u0154',
+ '\u0154'), ('\u0156', '\u0156'), ('\u0158', '\u0158'), ('\u015a', '\u015a'), ('\u015c',
+ '\u015c'), ('\u015e', '\u015e'), ('\u0160', '\u0160'), ('\u0162', '\u0162'), ('\u0164',
+ '\u0164'), ('\u0166', '\u0166'), ('\u0168', '\u0168'), ('\u016a', '\u016a'), ('\u016c',
+ '\u016c'), ('\u016e', '\u016e'), ('\u0170', '\u0170'), ('\u0172', '\u0172'), ('\u0174',
+ '\u0174'), ('\u0176', '\u0176'), ('\u0178', '\u0179'), ('\u017b', '\u017b'), ('\u017d',
+ '\u017d'), ('\u0181', '\u0182'), ('\u0184', '\u0184'), ('\u0186', '\u0187'), ('\u0189',
+ '\u018b'), ('\u018e', '\u0191'), ('\u0193', '\u0194'), ('\u0196', '\u0198'), ('\u019c',
+ '\u019d'), ('\u019f', '\u01a0'), ('\u01a2', '\u01a2'), ('\u01a4', '\u01a4'), ('\u01a6',
+ '\u01a7'), ('\u01a9', '\u01a9'), ('\u01ac', '\u01ac'), ('\u01ae', '\u01af'), ('\u01b1',
+ '\u01b3'), ('\u01b5', '\u01b5'), ('\u01b7', '\u01b8'), ('\u01bc', '\u01bc'), ('\u01c4',
+ '\u01c4'), ('\u01c7', '\u01c7'), ('\u01ca', '\u01ca'), ('\u01cd', '\u01cd'), ('\u01cf',
+ '\u01cf'), ('\u01d1', '\u01d1'), ('\u01d3', '\u01d3'), ('\u01d5', '\u01d5'), ('\u01d7',
+ '\u01d7'), ('\u01d9', '\u01d9'), ('\u01db', '\u01db'), ('\u01de', '\u01de'), ('\u01e0',
+ '\u01e0'), ('\u01e2', '\u01e2'), ('\u01e4', '\u01e4'), ('\u01e6', '\u01e6'), ('\u01e8',
+ '\u01e8'), ('\u01ea', '\u01ea'), ('\u01ec', '\u01ec'), ('\u01ee', '\u01ee'), ('\u01f1',
+ '\u01f1'), ('\u01f4', '\u01f4'), ('\u01f6', '\u01f8'), ('\u01fa', '\u01fa'), ('\u01fc',
+ '\u01fc'), ('\u01fe', '\u01fe'), ('\u0200', '\u0200'), ('\u0202', '\u0202'), ('\u0204',
+ '\u0204'), ('\u0206', '\u0206'), ('\u0208', '\u0208'), ('\u020a', '\u020a'), ('\u020c',
+ '\u020c'), ('\u020e', '\u020e'), ('\u0210', '\u0210'), ('\u0212', '\u0212'), ('\u0214',
+ '\u0214'), ('\u0216', '\u0216'), ('\u0218', '\u0218'), ('\u021a', '\u021a'), ('\u021c',
+ '\u021c'), ('\u021e', '\u021e'), ('\u0220', '\u0220'), ('\u0222', '\u0222'), ('\u0224',
+ '\u0224'), ('\u0226', '\u0226'), ('\u0228', '\u0228'), ('\u022a', '\u022a'), ('\u022c',
+ '\u022c'), ('\u022e', '\u022e'), ('\u0230', '\u0230'), ('\u0232', '\u0232'), ('\u023a',
+ '\u023b'), ('\u023d', '\u023e'), ('\u0241', '\u0241'), ('\u0243', '\u0246'), ('\u0248',
+ '\u0248'), ('\u024a', '\u024a'), ('\u024c', '\u024c'), ('\u024e', '\u024e'), ('\u0370',
+ '\u0370'), ('\u0372', '\u0372'), ('\u0376', '\u0376'), ('\u037f', '\u037f'), ('\u0386',
+ '\u0386'), ('\u0388', '\u038a'), ('\u038c', '\u038c'), ('\u038e', '\u038f'), ('\u0391',
+ '\u03a1'), ('\u03a3', '\u03ab'), ('\u03cf', '\u03cf'), ('\u03d2', '\u03d4'), ('\u03d8',
+ '\u03d8'), ('\u03da', '\u03da'), ('\u03dc', '\u03dc'), ('\u03de', '\u03de'), ('\u03e0',
+ '\u03e0'), ('\u03e2', '\u03e2'), ('\u03e4', '\u03e4'), ('\u03e6', '\u03e6'), ('\u03e8',
+ '\u03e8'), ('\u03ea', '\u03ea'), ('\u03ec', '\u03ec'), ('\u03ee', '\u03ee'), ('\u03f4',
+ '\u03f4'), ('\u03f7', '\u03f7'), ('\u03f9', '\u03fa'), ('\u03fd', '\u042f'), ('\u0460',
+ '\u0460'), ('\u0462', '\u0462'), ('\u0464', '\u0464'), ('\u0466', '\u0466'), ('\u0468',
+ '\u0468'), ('\u046a', '\u046a'), ('\u046c', '\u046c'), ('\u046e', '\u046e'), ('\u0470',
+ '\u0470'), ('\u0472', '\u0472'), ('\u0474', '\u0474'), ('\u0476', '\u0476'), ('\u0478',
+ '\u0478'), ('\u047a', '\u047a'), ('\u047c', '\u047c'), ('\u047e', '\u047e'), ('\u0480',
+ '\u0480'), ('\u048a', '\u048a'), ('\u048c', '\u048c'), ('\u048e', '\u048e'), ('\u0490',
+ '\u0490'), ('\u0492', '\u0492'), ('\u0494', '\u0494'), ('\u0496', '\u0496'), ('\u0498',
+ '\u0498'), ('\u049a', '\u049a'), ('\u049c', '\u049c'), ('\u049e', '\u049e'), ('\u04a0',
+ '\u04a0'), ('\u04a2', '\u04a2'), ('\u04a4', '\u04a4'), ('\u04a6', '\u04a6'), ('\u04a8',
+ '\u04a8'), ('\u04aa', '\u04aa'), ('\u04ac', '\u04ac'), ('\u04ae', '\u04ae'), ('\u04b0',
+ '\u04b0'), ('\u04b2', '\u04b2'), ('\u04b4', '\u04b4'), ('\u04b6', '\u04b6'), ('\u04b8',
+ '\u04b8'), ('\u04ba', '\u04ba'), ('\u04bc', '\u04bc'), ('\u04be', '\u04be'), ('\u04c0',
+ '\u04c1'), ('\u04c3', '\u04c3'), ('\u04c5', '\u04c5'), ('\u04c7', '\u04c7'), ('\u04c9',
+ '\u04c9'), ('\u04cb', '\u04cb'), ('\u04cd', '\u04cd'), ('\u04d0', '\u04d0'), ('\u04d2',
+ '\u04d2'), ('\u04d4', '\u04d4'), ('\u04d6', '\u04d6'), ('\u04d8', '\u04d8'), ('\u04da',
+ '\u04da'), ('\u04dc', '\u04dc'), ('\u04de', '\u04de'), ('\u04e0', '\u04e0'), ('\u04e2',
+ '\u04e2'), ('\u04e4', '\u04e4'), ('\u04e6', '\u04e6'), ('\u04e8', '\u04e8'), ('\u04ea',
+ '\u04ea'), ('\u04ec', '\u04ec'), ('\u04ee', '\u04ee'), ('\u04f0', '\u04f0'), ('\u04f2',
+ '\u04f2'), ('\u04f4', '\u04f4'), ('\u04f6', '\u04f6'), ('\u04f8', '\u04f8'), ('\u04fa',
+ '\u04fa'), ('\u04fc', '\u04fc'), ('\u04fe', '\u04fe'), ('\u0500', '\u0500'), ('\u0502',
+ '\u0502'), ('\u0504', '\u0504'), ('\u0506', '\u0506'), ('\u0508', '\u0508'), ('\u050a',
+ '\u050a'), ('\u050c', '\u050c'), ('\u050e', '\u050e'), ('\u0510', '\u0510'), ('\u0512',
+ '\u0512'), ('\u0514', '\u0514'), ('\u0516', '\u0516'), ('\u0518', '\u0518'), ('\u051a',
+ '\u051a'), ('\u051c', '\u051c'), ('\u051e', '\u051e'), ('\u0520', '\u0520'), ('\u0522',
+ '\u0522'), ('\u0524', '\u0524'), ('\u0526', '\u0526'), ('\u0528', '\u0528'), ('\u052a',
+ '\u052a'), ('\u052c', '\u052c'), ('\u052e', '\u052e'), ('\u0531', '\u0556'), ('\u10a0',
+ '\u10c5'), ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'), ('\u1e00', '\u1e00'), ('\u1e02',
+ '\u1e02'), ('\u1e04', '\u1e04'), ('\u1e06', '\u1e06'), ('\u1e08', '\u1e08'), ('\u1e0a',
+ '\u1e0a'), ('\u1e0c', '\u1e0c'), ('\u1e0e', '\u1e0e'), ('\u1e10', '\u1e10'), ('\u1e12',
+ '\u1e12'), ('\u1e14', '\u1e14'), ('\u1e16', '\u1e16'), ('\u1e18', '\u1e18'), ('\u1e1a',
+ '\u1e1a'), ('\u1e1c', '\u1e1c'), ('\u1e1e', '\u1e1e'), ('\u1e20', '\u1e20'), ('\u1e22',
+ '\u1e22'), ('\u1e24', '\u1e24'), ('\u1e26', '\u1e26'), ('\u1e28', '\u1e28'), ('\u1e2a',
+ '\u1e2a'), ('\u1e2c', '\u1e2c'), ('\u1e2e', '\u1e2e'), ('\u1e30', '\u1e30'), ('\u1e32',
+ '\u1e32'), ('\u1e34', '\u1e34'), ('\u1e36', '\u1e36'), ('\u1e38', '\u1e38'), ('\u1e3a',
+ '\u1e3a'), ('\u1e3c', '\u1e3c'), ('\u1e3e', '\u1e3e'), ('\u1e40', '\u1e40'), ('\u1e42',
+ '\u1e42'), ('\u1e44', '\u1e44'), ('\u1e46', '\u1e46'), ('\u1e48', '\u1e48'), ('\u1e4a',
+ '\u1e4a'), ('\u1e4c', '\u1e4c'), ('\u1e4e', '\u1e4e'), ('\u1e50', '\u1e50'), ('\u1e52',
+ '\u1e52'), ('\u1e54', '\u1e54'), ('\u1e56', '\u1e56'), ('\u1e58', '\u1e58'), ('\u1e5a',
+ '\u1e5a'), ('\u1e5c', '\u1e5c'), ('\u1e5e', '\u1e5e'), ('\u1e60', '\u1e60'), ('\u1e62',
+ '\u1e62'), ('\u1e64', '\u1e64'), ('\u1e66', '\u1e66'), ('\u1e68', '\u1e68'), ('\u1e6a',
+ '\u1e6a'), ('\u1e6c', '\u1e6c'), ('\u1e6e', '\u1e6e'), ('\u1e70', '\u1e70'), ('\u1e72',
+ '\u1e72'), ('\u1e74', '\u1e74'), ('\u1e76', '\u1e76'), ('\u1e78', '\u1e78'), ('\u1e7a',
+ '\u1e7a'), ('\u1e7c', '\u1e7c'), ('\u1e7e', '\u1e7e'), ('\u1e80', '\u1e80'), ('\u1e82',
+ '\u1e82'), ('\u1e84', '\u1e84'), ('\u1e86', '\u1e86'), ('\u1e88', '\u1e88'), ('\u1e8a',
+ '\u1e8a'), ('\u1e8c', '\u1e8c'), ('\u1e8e', '\u1e8e'), ('\u1e90', '\u1e90'), ('\u1e92',
+ '\u1e92'), ('\u1e94', '\u1e94'), ('\u1e9e', '\u1e9e'), ('\u1ea0', '\u1ea0'), ('\u1ea2',
+ '\u1ea2'), ('\u1ea4', '\u1ea4'), ('\u1ea6', '\u1ea6'), ('\u1ea8', '\u1ea8'), ('\u1eaa',
+ '\u1eaa'), ('\u1eac', '\u1eac'), ('\u1eae', '\u1eae'), ('\u1eb0', '\u1eb0'), ('\u1eb2',
+ '\u1eb2'), ('\u1eb4', '\u1eb4'), ('\u1eb6', '\u1eb6'), ('\u1eb8', '\u1eb8'), ('\u1eba',
+ '\u1eba'), ('\u1ebc', '\u1ebc'), ('\u1ebe', '\u1ebe'), ('\u1ec0', '\u1ec0'), ('\u1ec2',
+ '\u1ec2'), ('\u1ec4', '\u1ec4'), ('\u1ec6', '\u1ec6'), ('\u1ec8', '\u1ec8'), ('\u1eca',
+ '\u1eca'), ('\u1ecc', '\u1ecc'), ('\u1ece', '\u1ece'), ('\u1ed0', '\u1ed0'), ('\u1ed2',
+ '\u1ed2'), ('\u1ed4', '\u1ed4'), ('\u1ed6', '\u1ed6'), ('\u1ed8', '\u1ed8'), ('\u1eda',
+ '\u1eda'), ('\u1edc', '\u1edc'), ('\u1ede', '\u1ede'), ('\u1ee0', '\u1ee0'), ('\u1ee2',
+ '\u1ee2'), ('\u1ee4', '\u1ee4'), ('\u1ee6', '\u1ee6'), ('\u1ee8', '\u1ee8'), ('\u1eea',
+ '\u1eea'), ('\u1eec', '\u1eec'), ('\u1eee', '\u1eee'), ('\u1ef0', '\u1ef0'), ('\u1ef2',
+ '\u1ef2'), ('\u1ef4', '\u1ef4'), ('\u1ef6', '\u1ef6'), ('\u1ef8', '\u1ef8'), ('\u1efa',
+ '\u1efa'), ('\u1efc', '\u1efc'), ('\u1efe', '\u1efe'), ('\u1f08', '\u1f0f'), ('\u1f18',
+ '\u1f1d'), ('\u1f28', '\u1f2f'), ('\u1f38', '\u1f3f'), ('\u1f48', '\u1f4d'), ('\u1f59',
+ '\u1f59'), ('\u1f5b', '\u1f5b'), ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f5f'), ('\u1f68',
+ '\u1f6f'), ('\u1fb8', '\u1fbb'), ('\u1fc8', '\u1fcb'), ('\u1fd8', '\u1fdb'), ('\u1fe8',
+ '\u1fec'), ('\u1ff8', '\u1ffb'), ('\u2102', '\u2102'), ('\u2107', '\u2107'), ('\u210b',
+ '\u210d'), ('\u2110', '\u2112'), ('\u2115', '\u2115'), ('\u2119', '\u211d'), ('\u2124',
+ '\u2124'), ('\u2126', '\u2126'), ('\u2128', '\u2128'), ('\u212a', '\u212d'), ('\u2130',
+ '\u2133'), ('\u213e', '\u213f'), ('\u2145', '\u2145'), ('\u2160', '\u216f'), ('\u2183',
+ '\u2183'), ('\u24b6', '\u24cf'), ('\u2c00', '\u2c2e'), ('\u2c60', '\u2c60'), ('\u2c62',
+ '\u2c64'), ('\u2c67', '\u2c67'), ('\u2c69', '\u2c69'), ('\u2c6b', '\u2c6b'), ('\u2c6d',
+ '\u2c70'), ('\u2c72', '\u2c72'), ('\u2c75', '\u2c75'), ('\u2c7e', '\u2c80'), ('\u2c82',
+ '\u2c82'), ('\u2c84', '\u2c84'), ('\u2c86', '\u2c86'), ('\u2c88', '\u2c88'), ('\u2c8a',
+ '\u2c8a'), ('\u2c8c', '\u2c8c'), ('\u2c8e', '\u2c8e'), ('\u2c90', '\u2c90'), ('\u2c92',
+ '\u2c92'), ('\u2c94', '\u2c94'), ('\u2c96', '\u2c96'), ('\u2c98', '\u2c98'), ('\u2c9a',
+ '\u2c9a'), ('\u2c9c', '\u2c9c'), ('\u2c9e', '\u2c9e'), ('\u2ca0', '\u2ca0'), ('\u2ca2',
+ '\u2ca2'), ('\u2ca4', '\u2ca4'), ('\u2ca6', '\u2ca6'), ('\u2ca8', '\u2ca8'), ('\u2caa',
+ '\u2caa'), ('\u2cac', '\u2cac'), ('\u2cae', '\u2cae'), ('\u2cb0', '\u2cb0'), ('\u2cb2',
+ '\u2cb2'), ('\u2cb4', '\u2cb4'), ('\u2cb6', '\u2cb6'), ('\u2cb8', '\u2cb8'), ('\u2cba',
+ '\u2cba'), ('\u2cbc', '\u2cbc'), ('\u2cbe', '\u2cbe'), ('\u2cc0', '\u2cc0'), ('\u2cc2',
+ '\u2cc2'), ('\u2cc4', '\u2cc4'), ('\u2cc6', '\u2cc6'), ('\u2cc8', '\u2cc8'), ('\u2cca',
+ '\u2cca'), ('\u2ccc', '\u2ccc'), ('\u2cce', '\u2cce'), ('\u2cd0', '\u2cd0'), ('\u2cd2',
+ '\u2cd2'), ('\u2cd4', '\u2cd4'), ('\u2cd6', '\u2cd6'), ('\u2cd8', '\u2cd8'), ('\u2cda',
+ '\u2cda'), ('\u2cdc', '\u2cdc'), ('\u2cde', '\u2cde'), ('\u2ce0', '\u2ce0'), ('\u2ce2',
+ '\u2ce2'), ('\u2ceb', '\u2ceb'), ('\u2ced', '\u2ced'), ('\u2cf2', '\u2cf2'), ('\ua640',
+ '\ua640'), ('\ua642', '\ua642'), ('\ua644', '\ua644'), ('\ua646', '\ua646'), ('\ua648',
+ '\ua648'), ('\ua64a', '\ua64a'), ('\ua64c', '\ua64c'), ('\ua64e', '\ua64e'), ('\ua650',
+ '\ua650'), ('\ua652', '\ua652'), ('\ua654', '\ua654'), ('\ua656', '\ua656'), ('\ua658',
+ '\ua658'), ('\ua65a', '\ua65a'), ('\ua65c', '\ua65c'), ('\ua65e', '\ua65e'), ('\ua660',
+ '\ua660'), ('\ua662', '\ua662'), ('\ua664', '\ua664'), ('\ua666', '\ua666'), ('\ua668',
+ '\ua668'), ('\ua66a', '\ua66a'), ('\ua66c', '\ua66c'), ('\ua680', '\ua680'), ('\ua682',
+ '\ua682'), ('\ua684', '\ua684'), ('\ua686', '\ua686'), ('\ua688', '\ua688'), ('\ua68a',
+ '\ua68a'), ('\ua68c', '\ua68c'), ('\ua68e', '\ua68e'), ('\ua690', '\ua690'), ('\ua692',
+ '\ua692'), ('\ua694', '\ua694'), ('\ua696', '\ua696'), ('\ua698', '\ua698'), ('\ua69a',
+ '\ua69a'), ('\ua722', '\ua722'), ('\ua724', '\ua724'), ('\ua726', '\ua726'), ('\ua728',
+ '\ua728'), ('\ua72a', '\ua72a'), ('\ua72c', '\ua72c'), ('\ua72e', '\ua72e'), ('\ua732',
+ '\ua732'), ('\ua734', '\ua734'), ('\ua736', '\ua736'), ('\ua738', '\ua738'), ('\ua73a',
+ '\ua73a'), ('\ua73c', '\ua73c'), ('\ua73e', '\ua73e'), ('\ua740', '\ua740'), ('\ua742',
+ '\ua742'), ('\ua744', '\ua744'), ('\ua746', '\ua746'), ('\ua748', '\ua748'), ('\ua74a',
+ '\ua74a'), ('\ua74c', '\ua74c'), ('\ua74e', '\ua74e'), ('\ua750', '\ua750'), ('\ua752',
+ '\ua752'), ('\ua754', '\ua754'), ('\ua756', '\ua756'), ('\ua758', '\ua758'), ('\ua75a',
+ '\ua75a'), ('\ua75c', '\ua75c'), ('\ua75e', '\ua75e'), ('\ua760', '\ua760'), ('\ua762',
+ '\ua762'), ('\ua764', '\ua764'), ('\ua766', '\ua766'), ('\ua768', '\ua768'), ('\ua76a',
+ '\ua76a'), ('\ua76c', '\ua76c'), ('\ua76e', '\ua76e'), ('\ua779', '\ua779'), ('\ua77b',
+ '\ua77b'), ('\ua77d', '\ua77e'), ('\ua780', '\ua780'), ('\ua782', '\ua782'), ('\ua784',
+ '\ua784'), ('\ua786', '\ua786'), ('\ua78b', '\ua78b'), ('\ua78d', '\ua78d'), ('\ua790',
+ '\ua790'), ('\ua792', '\ua792'), ('\ua796', '\ua796'), ('\ua798', '\ua798'), ('\ua79a',
+ '\ua79a'), ('\ua79c', '\ua79c'), ('\ua79e', '\ua79e'), ('\ua7a0', '\ua7a0'), ('\ua7a2',
+ '\ua7a2'), ('\ua7a4', '\ua7a4'), ('\ua7a6', '\ua7a6'), ('\ua7a8', '\ua7a8'), ('\ua7aa',
+ '\ua7ad'), ('\ua7b0', '\ua7b1'), ('\uff21', '\uff3a'), ('\U00010400', '\U00010427'),
+ ('\U000118a0', '\U000118bf'), ('\U0001d400', '\U0001d419'), ('\U0001d434', '\U0001d44d'),
+ ('\U0001d468', '\U0001d481'), ('\U0001d49c', '\U0001d49c'), ('\U0001d49e', '\U0001d49f'),
+ ('\U0001d4a2', '\U0001d4a2'), ('\U0001d4a5', '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'),
+ ('\U0001d4ae', '\U0001d4b5'), ('\U0001d4d0', '\U0001d4e9'), ('\U0001d504', '\U0001d505'),
+ ('\U0001d507', '\U0001d50a'), ('\U0001d50d', '\U0001d514'), ('\U0001d516', '\U0001d51c'),
+ ('\U0001d538', '\U0001d539'), ('\U0001d53b', '\U0001d53e'), ('\U0001d540', '\U0001d544'),
+ ('\U0001d546', '\U0001d546'), ('\U0001d54a', '\U0001d550'), ('\U0001d56c', '\U0001d585'),
+ ('\U0001d5a0', '\U0001d5b9'), ('\U0001d5d4', '\U0001d5ed'), ('\U0001d608', '\U0001d621'),
+ ('\U0001d63c', '\U0001d655'), ('\U0001d670', '\U0001d689'), ('\U0001d6a8', '\U0001d6c0'),
+ ('\U0001d6e2', '\U0001d6fa'), ('\U0001d71c', '\U0001d734'), ('\U0001d756', '\U0001d76e'),
+ ('\U0001d790', '\U0001d7a8'), ('\U0001d7ca', '\U0001d7ca'), ('\U0001f130', '\U0001f149'),
+ ('\U0001f150', '\U0001f169'), ('\U0001f170', '\U0001f189')
+ ];
+
+ pub fn Uppercase(c: char) -> bool {
+ super::bsearch_range_table(c, Uppercase_table)
+ }
+
+ pub static XID_Continue_table: &'static [(char, char)] = &[
+ ('\x30', '\x39'), ('\x41', '\x5a'), ('\x5f', '\x5f'), ('\x61', '\x7a'), ('\xaa', '\xaa'),
+ ('\xb5', '\xb5'), ('\xb7', '\xb7'), ('\xba', '\xba'), ('\xc0', '\xd6'), ('\xd8', '\xf6'),
+ ('\xf8', '\u01ba'), ('\u01bb', '\u01bb'), ('\u01bc', '\u01bf'), ('\u01c0', '\u01c3'),
+ ('\u01c4', '\u0293'), ('\u0294', '\u0294'), ('\u0295', '\u02af'), ('\u02b0', '\u02c1'),
+ ('\u02c6', '\u02d1'), ('\u02e0', '\u02e4'), ('\u02ec', '\u02ec'), ('\u02ee', '\u02ee'),
+ ('\u0300', '\u036f'), ('\u0370', '\u0373'), ('\u0374', '\u0374'), ('\u0376', '\u0377'),
+ ('\u037b', '\u037d'), ('\u037f', '\u037f'), ('\u0386', '\u0386'), ('\u0387', '\u0387'),
+ ('\u0388', '\u038a'), ('\u038c', '\u038c'), ('\u038e', '\u03a1'), ('\u03a3', '\u03f5'),
+ ('\u03f7', '\u0481'), ('\u0483', '\u0487'), ('\u048a', '\u052f'), ('\u0531', '\u0556'),
+ ('\u0559', '\u0559'), ('\u0561', '\u0587'), ('\u0591', '\u05bd'), ('\u05bf', '\u05bf'),
+ ('\u05c1', '\u05c2'), ('\u05c4', '\u05c5'), ('\u05c7', '\u05c7'), ('\u05d0', '\u05ea'),
+ ('\u05f0', '\u05f2'), ('\u0610', '\u061a'), ('\u0620', '\u063f'), ('\u0640', '\u0640'),
+ ('\u0641', '\u064a'), ('\u064b', '\u065f'), ('\u0660', '\u0669'), ('\u066e', '\u066f'),
+ ('\u0670', '\u0670'), ('\u0671', '\u06d3'), ('\u06d5', '\u06d5'), ('\u06d6', '\u06dc'),
+ ('\u06df', '\u06e4'), ('\u06e5', '\u06e6'), ('\u06e7', '\u06e8'), ('\u06ea', '\u06ed'),
+ ('\u06ee', '\u06ef'), ('\u06f0', '\u06f9'), ('\u06fa', '\u06fc'), ('\u06ff', '\u06ff'),
+ ('\u0710', '\u0710'), ('\u0711', '\u0711'), ('\u0712', '\u072f'), ('\u0730', '\u074a'),
+ ('\u074d', '\u07a5'), ('\u07a6', '\u07b0'), ('\u07b1', '\u07b1'), ('\u07c0', '\u07c9'),
+ ('\u07ca', '\u07ea'), ('\u07eb', '\u07f3'), ('\u07f4', '\u07f5'), ('\u07fa', '\u07fa'),
+ ('\u0800', '\u0815'), ('\u0816', '\u0819'), ('\u081a', '\u081a'), ('\u081b', '\u0823'),
+ ('\u0824', '\u0824'), ('\u0825', '\u0827'), ('\u0828', '\u0828'), ('\u0829', '\u082d'),
+ ('\u0840', '\u0858'), ('\u0859', '\u085b'), ('\u08a0', '\u08b2'), ('\u08e4', '\u0902'),
+ ('\u0903', '\u0903'), ('\u0904', '\u0939'), ('\u093a', '\u093a'), ('\u093b', '\u093b'),
+ ('\u093c', '\u093c'), ('\u093d', '\u093d'), ('\u093e', '\u0940'), ('\u0941', '\u0948'),
+ ('\u0949', '\u094c'), ('\u094d', '\u094d'), ('\u094e', '\u094f'), ('\u0950', '\u0950'),
+ ('\u0951', '\u0957'), ('\u0958', '\u0961'), ('\u0962', '\u0963'), ('\u0966', '\u096f'),
+ ('\u0971', '\u0971'), ('\u0972', '\u0980'), ('\u0981', '\u0981'), ('\u0982', '\u0983'),
+ ('\u0985', '\u098c'), ('\u098f', '\u0990'), ('\u0993', '\u09a8'), ('\u09aa', '\u09b0'),
+ ('\u09b2', '\u09b2'), ('\u09b6', '\u09b9'), ('\u09bc', '\u09bc'), ('\u09bd', '\u09bd'),
+ ('\u09be', '\u09c0'), ('\u09c1', '\u09c4'), ('\u09c7', '\u09c8'), ('\u09cb', '\u09cc'),
+ ('\u09cd', '\u09cd'), ('\u09ce', '\u09ce'), ('\u09d7', '\u09d7'), ('\u09dc', '\u09dd'),
+ ('\u09df', '\u09e1'), ('\u09e2', '\u09e3'), ('\u09e6', '\u09ef'), ('\u09f0', '\u09f1'),
+ ('\u0a01', '\u0a02'), ('\u0a03', '\u0a03'), ('\u0a05', '\u0a0a'), ('\u0a0f', '\u0a10'),
+ ('\u0a13', '\u0a28'), ('\u0a2a', '\u0a30'), ('\u0a32', '\u0a33'), ('\u0a35', '\u0a36'),
+ ('\u0a38', '\u0a39'), ('\u0a3c', '\u0a3c'), ('\u0a3e', '\u0a40'), ('\u0a41', '\u0a42'),
+ ('\u0a47', '\u0a48'), ('\u0a4b', '\u0a4d'), ('\u0a51', '\u0a51'), ('\u0a59', '\u0a5c'),
+ ('\u0a5e', '\u0a5e'), ('\u0a66', '\u0a6f'), ('\u0a70', '\u0a71'), ('\u0a72', '\u0a74'),
+ ('\u0a75', '\u0a75'), ('\u0a81', '\u0a82'), ('\u0a83', '\u0a83'), ('\u0a85', '\u0a8d'),
+ ('\u0a8f', '\u0a91'), ('\u0a93', '\u0aa8'), ('\u0aaa', '\u0ab0'), ('\u0ab2', '\u0ab3'),
+ ('\u0ab5', '\u0ab9'), ('\u0abc', '\u0abc'), ('\u0abd', '\u0abd'), ('\u0abe', '\u0ac0'),
+ ('\u0ac1', '\u0ac5'), ('\u0ac7', '\u0ac8'), ('\u0ac9', '\u0ac9'), ('\u0acb', '\u0acc'),
+ ('\u0acd', '\u0acd'), ('\u0ad0', '\u0ad0'), ('\u0ae0', '\u0ae1'), ('\u0ae2', '\u0ae3'),
+ ('\u0ae6', '\u0aef'), ('\u0b01', '\u0b01'), ('\u0b02', '\u0b03'), ('\u0b05', '\u0b0c'),
+ ('\u0b0f', '\u0b10'), ('\u0b13', '\u0b28'), ('\u0b2a', '\u0b30'), ('\u0b32', '\u0b33'),
+ ('\u0b35', '\u0b39'), ('\u0b3c', '\u0b3c'), ('\u0b3d', '\u0b3d'), ('\u0b3e', '\u0b3e'),
+ ('\u0b3f', '\u0b3f'), ('\u0b40', '\u0b40'), ('\u0b41', '\u0b44'), ('\u0b47', '\u0b48'),
+ ('\u0b4b', '\u0b4c'), ('\u0b4d', '\u0b4d'), ('\u0b56', '\u0b56'), ('\u0b57', '\u0b57'),
+ ('\u0b5c', '\u0b5d'), ('\u0b5f', '\u0b61'), ('\u0b62', '\u0b63'), ('\u0b66', '\u0b6f'),
+ ('\u0b71', '\u0b71'), ('\u0b82', '\u0b82'), ('\u0b83', '\u0b83'), ('\u0b85', '\u0b8a'),
+ ('\u0b8e', '\u0b90'), ('\u0b92', '\u0b95'), ('\u0b99', '\u0b9a'), ('\u0b9c', '\u0b9c'),
+ ('\u0b9e', '\u0b9f'), ('\u0ba3', '\u0ba4'), ('\u0ba8', '\u0baa'), ('\u0bae', '\u0bb9'),
+ ('\u0bbe', '\u0bbf'), ('\u0bc0', '\u0bc0'), ('\u0bc1', '\u0bc2'), ('\u0bc6', '\u0bc8'),
+ ('\u0bca', '\u0bcc'), ('\u0bcd', '\u0bcd'), ('\u0bd0', '\u0bd0'), ('\u0bd7', '\u0bd7'),
+ ('\u0be6', '\u0bef'), ('\u0c00', '\u0c00'), ('\u0c01', '\u0c03'), ('\u0c05', '\u0c0c'),
+ ('\u0c0e', '\u0c10'), ('\u0c12', '\u0c28'), ('\u0c2a', '\u0c39'), ('\u0c3d', '\u0c3d'),
+ ('\u0c3e', '\u0c40'), ('\u0c41', '\u0c44'), ('\u0c46', '\u0c48'), ('\u0c4a', '\u0c4d'),
+ ('\u0c55', '\u0c56'), ('\u0c58', '\u0c59'), ('\u0c60', '\u0c61'), ('\u0c62', '\u0c63'),
+ ('\u0c66', '\u0c6f'), ('\u0c81', '\u0c81'), ('\u0c82', '\u0c83'), ('\u0c85', '\u0c8c'),
+ ('\u0c8e', '\u0c90'), ('\u0c92', '\u0ca8'), ('\u0caa', '\u0cb3'), ('\u0cb5', '\u0cb9'),
+ ('\u0cbc', '\u0cbc'), ('\u0cbd', '\u0cbd'), ('\u0cbe', '\u0cbe'), ('\u0cbf', '\u0cbf'),
+ ('\u0cc0', '\u0cc4'), ('\u0cc6', '\u0cc6'), ('\u0cc7', '\u0cc8'), ('\u0cca', '\u0ccb'),
+ ('\u0ccc', '\u0ccd'), ('\u0cd5', '\u0cd6'), ('\u0cde', '\u0cde'), ('\u0ce0', '\u0ce1'),
+ ('\u0ce2', '\u0ce3'), ('\u0ce6', '\u0cef'), ('\u0cf1', '\u0cf2'), ('\u0d01', '\u0d01'),
+ ('\u0d02', '\u0d03'), ('\u0d05', '\u0d0c'), ('\u0d0e', '\u0d10'), ('\u0d12', '\u0d3a'),
+ ('\u0d3d', '\u0d3d'), ('\u0d3e', '\u0d40'), ('\u0d41', '\u0d44'), ('\u0d46', '\u0d48'),
+ ('\u0d4a', '\u0d4c'), ('\u0d4d', '\u0d4d'), ('\u0d4e', '\u0d4e'), ('\u0d57', '\u0d57'),
+ ('\u0d60', '\u0d61'), ('\u0d62', '\u0d63'), ('\u0d66', '\u0d6f'), ('\u0d7a', '\u0d7f'),
+ ('\u0d82', '\u0d83'), ('\u0d85', '\u0d96'), ('\u0d9a', '\u0db1'), ('\u0db3', '\u0dbb'),
+ ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'), ('\u0dca', '\u0dca'), ('\u0dcf', '\u0dd1'),
+ ('\u0dd2', '\u0dd4'), ('\u0dd6', '\u0dd6'), ('\u0dd8', '\u0ddf'), ('\u0de6', '\u0def'),
+ ('\u0df2', '\u0df3'), ('\u0e01', '\u0e30'), ('\u0e31', '\u0e31'), ('\u0e32', '\u0e33'),
+ ('\u0e34', '\u0e3a'), ('\u0e40', '\u0e45'), ('\u0e46', '\u0e46'), ('\u0e47', '\u0e4e'),
+ ('\u0e50', '\u0e59'), ('\u0e81', '\u0e82'), ('\u0e84', '\u0e84'), ('\u0e87', '\u0e88'),
+ ('\u0e8a', '\u0e8a'), ('\u0e8d', '\u0e8d'), ('\u0e94', '\u0e97'), ('\u0e99', '\u0e9f'),
+ ('\u0ea1', '\u0ea3'), ('\u0ea5', '\u0ea5'), ('\u0ea7', '\u0ea7'), ('\u0eaa', '\u0eab'),
+ ('\u0ead', '\u0eb0'), ('\u0eb1', '\u0eb1'), ('\u0eb2', '\u0eb3'), ('\u0eb4', '\u0eb9'),
+ ('\u0ebb', '\u0ebc'), ('\u0ebd', '\u0ebd'), ('\u0ec0', '\u0ec4'), ('\u0ec6', '\u0ec6'),
+ ('\u0ec8', '\u0ecd'), ('\u0ed0', '\u0ed9'), ('\u0edc', '\u0edf'), ('\u0f00', '\u0f00'),
+ ('\u0f18', '\u0f19'), ('\u0f20', '\u0f29'), ('\u0f35', '\u0f35'), ('\u0f37', '\u0f37'),
+ ('\u0f39', '\u0f39'), ('\u0f3e', '\u0f3f'), ('\u0f40', '\u0f47'), ('\u0f49', '\u0f6c'),
+ ('\u0f71', '\u0f7e'), ('\u0f7f', '\u0f7f'), ('\u0f80', '\u0f84'), ('\u0f86', '\u0f87'),
+ ('\u0f88', '\u0f8c'), ('\u0f8d', '\u0f97'), ('\u0f99', '\u0fbc'), ('\u0fc6', '\u0fc6'),
+ ('\u1000', '\u102a'), ('\u102b', '\u102c'), ('\u102d', '\u1030'), ('\u1031', '\u1031'),
+ ('\u1032', '\u1037'), ('\u1038', '\u1038'), ('\u1039', '\u103a'), ('\u103b', '\u103c'),
+ ('\u103d', '\u103e'), ('\u103f', '\u103f'), ('\u1040', '\u1049'), ('\u1050', '\u1055'),
+ ('\u1056', '\u1057'), ('\u1058', '\u1059'), ('\u105a', '\u105d'), ('\u105e', '\u1060'),
+ ('\u1061', '\u1061'), ('\u1062', '\u1064'), ('\u1065', '\u1066'), ('\u1067', '\u106d'),
+ ('\u106e', '\u1070'), ('\u1071', '\u1074'), ('\u1075', '\u1081'), ('\u1082', '\u1082'),
+ ('\u1083', '\u1084'), ('\u1085', '\u1086'), ('\u1087', '\u108c'), ('\u108d', '\u108d'),
+ ('\u108e', '\u108e'), ('\u108f', '\u108f'), ('\u1090', '\u1099'), ('\u109a', '\u109c'),
+ ('\u109d', '\u109d'), ('\u10a0', '\u10c5'), ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'),
+ ('\u10d0', '\u10fa'), ('\u10fc', '\u10fc'), ('\u10fd', '\u1248'), ('\u124a', '\u124d'),
+ ('\u1250', '\u1256'), ('\u1258', '\u1258'), ('\u125a', '\u125d'), ('\u1260', '\u1288'),
+ ('\u128a', '\u128d'), ('\u1290', '\u12b0'), ('\u12b2', '\u12b5'), ('\u12b8', '\u12be'),
+ ('\u12c0', '\u12c0'), ('\u12c2', '\u12c5'), ('\u12c8', '\u12d6'), ('\u12d8', '\u1310'),
+ ('\u1312', '\u1315'), ('\u1318', '\u135a'), ('\u135d', '\u135f'), ('\u1369', '\u1371'),
+ ('\u1380', '\u138f'), ('\u13a0', '\u13f4'), ('\u1401', '\u166c'), ('\u166f', '\u167f'),
+ ('\u1681', '\u169a'), ('\u16a0', '\u16ea'), ('\u16ee', '\u16f0'), ('\u16f1', '\u16f8'),
+ ('\u1700', '\u170c'), ('\u170e', '\u1711'), ('\u1712', '\u1714'), ('\u1720', '\u1731'),
+ ('\u1732', '\u1734'), ('\u1740', '\u1751'), ('\u1752', '\u1753'), ('\u1760', '\u176c'),
+ ('\u176e', '\u1770'), ('\u1772', '\u1773'), ('\u1780', '\u17b3'), ('\u17b4', '\u17b5'),
+ ('\u17b6', '\u17b6'), ('\u17b7', '\u17bd'), ('\u17be', '\u17c5'), ('\u17c6', '\u17c6'),
+ ('\u17c7', '\u17c8'), ('\u17c9', '\u17d3'), ('\u17d7', '\u17d7'), ('\u17dc', '\u17dc'),
+ ('\u17dd', '\u17dd'), ('\u17e0', '\u17e9'), ('\u180b', '\u180d'), ('\u1810', '\u1819'),
+ ('\u1820', '\u1842'), ('\u1843', '\u1843'), ('\u1844', '\u1877'), ('\u1880', '\u18a8'),
+ ('\u18a9', '\u18a9'), ('\u18aa', '\u18aa'), ('\u18b0', '\u18f5'), ('\u1900', '\u191e'),
+ ('\u1920', '\u1922'), ('\u1923', '\u1926'), ('\u1927', '\u1928'), ('\u1929', '\u192b'),
+ ('\u1930', '\u1931'), ('\u1932', '\u1932'), ('\u1933', '\u1938'), ('\u1939', '\u193b'),
+ ('\u1946', '\u194f'), ('\u1950', '\u196d'), ('\u1970', '\u1974'), ('\u1980', '\u19ab'),
+ ('\u19b0', '\u19c0'), ('\u19c1', '\u19c7'), ('\u19c8', '\u19c9'), ('\u19d0', '\u19d9'),
+ ('\u19da', '\u19da'), ('\u1a00', '\u1a16'), ('\u1a17', '\u1a18'), ('\u1a19', '\u1a1a'),
+ ('\u1a1b', '\u1a1b'), ('\u1a20', '\u1a54'), ('\u1a55', '\u1a55'), ('\u1a56', '\u1a56'),
+ ('\u1a57', '\u1a57'), ('\u1a58', '\u1a5e'), ('\u1a60', '\u1a60'), ('\u1a61', '\u1a61'),
+ ('\u1a62', '\u1a62'), ('\u1a63', '\u1a64'), ('\u1a65', '\u1a6c'), ('\u1a6d', '\u1a72'),
+ ('\u1a73', '\u1a7c'), ('\u1a7f', '\u1a7f'), ('\u1a80', '\u1a89'), ('\u1a90', '\u1a99'),
+ ('\u1aa7', '\u1aa7'), ('\u1ab0', '\u1abd'), ('\u1b00', '\u1b03'), ('\u1b04', '\u1b04'),
+ ('\u1b05', '\u1b33'), ('\u1b34', '\u1b34'), ('\u1b35', '\u1b35'), ('\u1b36', '\u1b3a'),
+ ('\u1b3b', '\u1b3b'), ('\u1b3c', '\u1b3c'), ('\u1b3d', '\u1b41'), ('\u1b42', '\u1b42'),
+ ('\u1b43', '\u1b44'), ('\u1b45', '\u1b4b'), ('\u1b50', '\u1b59'), ('\u1b6b', '\u1b73'),
+ ('\u1b80', '\u1b81'), ('\u1b82', '\u1b82'), ('\u1b83', '\u1ba0'), ('\u1ba1', '\u1ba1'),
+ ('\u1ba2', '\u1ba5'), ('\u1ba6', '\u1ba7'), ('\u1ba8', '\u1ba9'), ('\u1baa', '\u1baa'),
+ ('\u1bab', '\u1bad'), ('\u1bae', '\u1baf'), ('\u1bb0', '\u1bb9'), ('\u1bba', '\u1be5'),
+ ('\u1be6', '\u1be6'), ('\u1be7', '\u1be7'), ('\u1be8', '\u1be9'), ('\u1bea', '\u1bec'),
+ ('\u1bed', '\u1bed'), ('\u1bee', '\u1bee'), ('\u1bef', '\u1bf1'), ('\u1bf2', '\u1bf3'),
+ ('\u1c00', '\u1c23'), ('\u1c24', '\u1c2b'), ('\u1c2c', '\u1c33'), ('\u1c34', '\u1c35'),
+ ('\u1c36', '\u1c37'), ('\u1c40', '\u1c49'), ('\u1c4d', '\u1c4f'), ('\u1c50', '\u1c59'),
+ ('\u1c5a', '\u1c77'), ('\u1c78', '\u1c7d'), ('\u1cd0', '\u1cd2'), ('\u1cd4', '\u1ce0'),
+ ('\u1ce1', '\u1ce1'), ('\u1ce2', '\u1ce8'), ('\u1ce9', '\u1cec'), ('\u1ced', '\u1ced'),
+ ('\u1cee', '\u1cf1'), ('\u1cf2', '\u1cf3'), ('\u1cf4', '\u1cf4'), ('\u1cf5', '\u1cf6'),
+ ('\u1cf8', '\u1cf9'), ('\u1d00', '\u1d2b'), ('\u1d2c', '\u1d6a'), ('\u1d6b', '\u1d77'),
+ ('\u1d78', '\u1d78'), ('\u1d79', '\u1d9a'), ('\u1d9b', '\u1dbf'), ('\u1dc0', '\u1df5'),
+ ('\u1dfc', '\u1dff'), ('\u1e00', '\u1f15'), ('\u1f18', '\u1f1d'), ('\u1f20', '\u1f45'),
+ ('\u1f48', '\u1f4d'), ('\u1f50', '\u1f57'), ('\u1f59', '\u1f59'), ('\u1f5b', '\u1f5b'),
+ ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f7d'), ('\u1f80', '\u1fb4'), ('\u1fb6', '\u1fbc'),
+ ('\u1fbe', '\u1fbe'), ('\u1fc2', '\u1fc4'), ('\u1fc6', '\u1fcc'), ('\u1fd0', '\u1fd3'),
+ ('\u1fd6', '\u1fdb'), ('\u1fe0', '\u1fec'), ('\u1ff2', '\u1ff4'), ('\u1ff6', '\u1ffc'),
+ ('\u203f', '\u2040'), ('\u2054', '\u2054'), ('\u2071', '\u2071'), ('\u207f', '\u207f'),
+ ('\u2090', '\u209c'), ('\u20d0', '\u20dc'), ('\u20e1', '\u20e1'), ('\u20e5', '\u20f0'),
+ ('\u2102', '\u2102'), ('\u2107', '\u2107'), ('\u210a', '\u2113'), ('\u2115', '\u2115'),
+ ('\u2118', '\u2118'), ('\u2119', '\u211d'), ('\u2124', '\u2124'), ('\u2126', '\u2126'),
+ ('\u2128', '\u2128'), ('\u212a', '\u212d'), ('\u212e', '\u212e'), ('\u212f', '\u2134'),
+ ('\u2135', '\u2138'), ('\u2139', '\u2139'), ('\u213c', '\u213f'), ('\u2145', '\u2149'),
+ ('\u214e', '\u214e'), ('\u2160', '\u2182'), ('\u2183', '\u2184'), ('\u2185', '\u2188'),
+ ('\u2c00', '\u2c2e'), ('\u2c30', '\u2c5e'), ('\u2c60', '\u2c7b'), ('\u2c7c', '\u2c7d'),
+ ('\u2c7e', '\u2ce4'), ('\u2ceb', '\u2cee'), ('\u2cef', '\u2cf1'), ('\u2cf2', '\u2cf3'),
+ ('\u2d00', '\u2d25'), ('\u2d27', '\u2d27'), ('\u2d2d', '\u2d2d'), ('\u2d30', '\u2d67'),
+ ('\u2d6f', '\u2d6f'), ('\u2d7f', '\u2d7f'), ('\u2d80', '\u2d96'), ('\u2da0', '\u2da6'),
+ ('\u2da8', '\u2dae'), ('\u2db0', '\u2db6'), ('\u2db8', '\u2dbe'), ('\u2dc0', '\u2dc6'),
+ ('\u2dc8', '\u2dce'), ('\u2dd0', '\u2dd6'), ('\u2dd8', '\u2dde'), ('\u2de0', '\u2dff'),
+ ('\u3005', '\u3005'), ('\u3006', '\u3006'), ('\u3007', '\u3007'), ('\u3021', '\u3029'),
+ ('\u302a', '\u302d'), ('\u302e', '\u302f'), ('\u3031', '\u3035'), ('\u3038', '\u303a'),
+ ('\u303b', '\u303b'), ('\u303c', '\u303c'), ('\u3041', '\u3096'), ('\u3099', '\u309a'),
+ ('\u309d', '\u309e'), ('\u309f', '\u309f'), ('\u30a1', '\u30fa'), ('\u30fc', '\u30fe'),
+ ('\u30ff', '\u30ff'), ('\u3105', '\u312d'), ('\u3131', '\u318e'), ('\u31a0', '\u31ba'),
+ ('\u31f0', '\u31ff'), ('\u3400', '\u4db5'), ('\u4e00', '\u9fcc'), ('\ua000', '\ua014'),
+ ('\ua015', '\ua015'), ('\ua016', '\ua48c'), ('\ua4d0', '\ua4f7'), ('\ua4f8', '\ua4fd'),
+ ('\ua500', '\ua60b'), ('\ua60c', '\ua60c'), ('\ua610', '\ua61f'), ('\ua620', '\ua629'),
+ ('\ua62a', '\ua62b'), ('\ua640', '\ua66d'), ('\ua66e', '\ua66e'), ('\ua66f', '\ua66f'),
+ ('\ua674', '\ua67d'), ('\ua67f', '\ua67f'), ('\ua680', '\ua69b'), ('\ua69c', '\ua69d'),
+ ('\ua69f', '\ua69f'), ('\ua6a0', '\ua6e5'), ('\ua6e6', '\ua6ef'), ('\ua6f0', '\ua6f1'),
+ ('\ua717', '\ua71f'), ('\ua722', '\ua76f'), ('\ua770', '\ua770'), ('\ua771', '\ua787'),
+ ('\ua788', '\ua788'), ('\ua78b', '\ua78e'), ('\ua790', '\ua7ad'), ('\ua7b0', '\ua7b1'),
+ ('\ua7f7', '\ua7f7'), ('\ua7f8', '\ua7f9'), ('\ua7fa', '\ua7fa'), ('\ua7fb', '\ua801'),
+ ('\ua802', '\ua802'), ('\ua803', '\ua805'), ('\ua806', '\ua806'), ('\ua807', '\ua80a'),
+ ('\ua80b', '\ua80b'), ('\ua80c', '\ua822'), ('\ua823', '\ua824'), ('\ua825', '\ua826'),
+ ('\ua827', '\ua827'), ('\ua840', '\ua873'), ('\ua880', '\ua881'), ('\ua882', '\ua8b3'),
+ ('\ua8b4', '\ua8c3'), ('\ua8c4', '\ua8c4'), ('\ua8d0', '\ua8d9'), ('\ua8e0', '\ua8f1'),
+ ('\ua8f2', '\ua8f7'), ('\ua8fb', '\ua8fb'), ('\ua900', '\ua909'), ('\ua90a', '\ua925'),
+ ('\ua926', '\ua92d'), ('\ua930', '\ua946'), ('\ua947', '\ua951'), ('\ua952', '\ua953'),
+ ('\ua960', '\ua97c'), ('\ua980', '\ua982'), ('\ua983', '\ua983'), ('\ua984', '\ua9b2'),
+ ('\ua9b3', '\ua9b3'), ('\ua9b4', '\ua9b5'), ('\ua9b6', '\ua9b9'), ('\ua9ba', '\ua9bb'),
+ ('\ua9bc', '\ua9bc'), ('\ua9bd', '\ua9c0'), ('\ua9cf', '\ua9cf'), ('\ua9d0', '\ua9d9'),
+ ('\ua9e0', '\ua9e4'), ('\ua9e5', '\ua9e5'), ('\ua9e6', '\ua9e6'), ('\ua9e7', '\ua9ef'),
+ ('\ua9f0', '\ua9f9'), ('\ua9fa', '\ua9fe'), ('\uaa00', '\uaa28'), ('\uaa29', '\uaa2e'),
+ ('\uaa2f', '\uaa30'), ('\uaa31', '\uaa32'), ('\uaa33', '\uaa34'), ('\uaa35', '\uaa36'),
+ ('\uaa40', '\uaa42'), ('\uaa43', '\uaa43'), ('\uaa44', '\uaa4b'), ('\uaa4c', '\uaa4c'),
+ ('\uaa4d', '\uaa4d'), ('\uaa50', '\uaa59'), ('\uaa60', '\uaa6f'), ('\uaa70', '\uaa70'),
+ ('\uaa71', '\uaa76'), ('\uaa7a', '\uaa7a'), ('\uaa7b', '\uaa7b'), ('\uaa7c', '\uaa7c'),
+ ('\uaa7d', '\uaa7d'), ('\uaa7e', '\uaaaf'), ('\uaab0', '\uaab0'), ('\uaab1', '\uaab1'),
+ ('\uaab2', '\uaab4'), ('\uaab5', '\uaab6'), ('\uaab7', '\uaab8'), ('\uaab9', '\uaabd'),
+ ('\uaabe', '\uaabf'), ('\uaac0', '\uaac0'), ('\uaac1', '\uaac1'), ('\uaac2', '\uaac2'),
+ ('\uaadb', '\uaadc'), ('\uaadd', '\uaadd'), ('\uaae0', '\uaaea'), ('\uaaeb', '\uaaeb'),
+ ('\uaaec', '\uaaed'), ('\uaaee', '\uaaef'), ('\uaaf2', '\uaaf2'), ('\uaaf3', '\uaaf4'),
+ ('\uaaf5', '\uaaf5'), ('\uaaf6', '\uaaf6'), ('\uab01', '\uab06'), ('\uab09', '\uab0e'),
+ ('\uab11', '\uab16'), ('\uab20', '\uab26'), ('\uab28', '\uab2e'), ('\uab30', '\uab5a'),
+ ('\uab5c', '\uab5f'), ('\uab64', '\uab65'), ('\uabc0', '\uabe2'), ('\uabe3', '\uabe4'),
+ ('\uabe5', '\uabe5'), ('\uabe6', '\uabe7'), ('\uabe8', '\uabe8'), ('\uabe9', '\uabea'),
+ ('\uabec', '\uabec'), ('\uabed', '\uabed'), ('\uabf0', '\uabf9'), ('\uac00', '\ud7a3'),
+ ('\ud7b0', '\ud7c6'), ('\ud7cb', '\ud7fb'), ('\uf900', '\ufa6d'), ('\ufa70', '\ufad9'),
+ ('\ufb00', '\ufb06'), ('\ufb13', '\ufb17'), ('\ufb1d', '\ufb1d'), ('\ufb1e', '\ufb1e'),
+ ('\ufb1f', '\ufb28'), ('\ufb2a', '\ufb36'), ('\ufb38', '\ufb3c'), ('\ufb3e', '\ufb3e'),
+ ('\ufb40', '\ufb41'), ('\ufb43', '\ufb44'), ('\ufb46', '\ufbb1'), ('\ufbd3', '\ufc5d'),
+ ('\ufc64', '\ufd3d'), ('\ufd50', '\ufd8f'), ('\ufd92', '\ufdc7'), ('\ufdf0', '\ufdf9'),
+ ('\ufe00', '\ufe0f'), ('\ufe20', '\ufe2d'), ('\ufe33', '\ufe34'), ('\ufe4d', '\ufe4f'),
+ ('\ufe71', '\ufe71'), ('\ufe73', '\ufe73'), ('\ufe77', '\ufe77'), ('\ufe79', '\ufe79'),
+ ('\ufe7b', '\ufe7b'), ('\ufe7d', '\ufe7d'), ('\ufe7f', '\ufefc'), ('\uff10', '\uff19'),
+ ('\uff21', '\uff3a'), ('\uff3f', '\uff3f'), ('\uff41', '\uff5a'), ('\uff66', '\uff6f'),
+ ('\uff70', '\uff70'), ('\uff71', '\uff9d'), ('\uff9e', '\uff9f'), ('\uffa0', '\uffbe'),
+ ('\uffc2', '\uffc7'), ('\uffca', '\uffcf'), ('\uffd2', '\uffd7'), ('\uffda', '\uffdc'),
+ ('\U00010000', '\U0001000b'), ('\U0001000d', '\U00010026'), ('\U00010028', '\U0001003a'),
+ ('\U0001003c', '\U0001003d'), ('\U0001003f', '\U0001004d'), ('\U00010050', '\U0001005d'),
+ ('\U00010080', '\U000100fa'), ('\U00010140', '\U00010174'), ('\U000101fd', '\U000101fd'),
+ ('\U00010280', '\U0001029c'), ('\U000102a0', '\U000102d0'), ('\U000102e0', '\U000102e0'),
+ ('\U00010300', '\U0001031f'), ('\U00010330', '\U00010340'), ('\U00010341', '\U00010341'),
+ ('\U00010342', '\U00010349'), ('\U0001034a', '\U0001034a'), ('\U00010350', '\U00010375'),
+ ('\U00010376', '\U0001037a'), ('\U00010380', '\U0001039d'), ('\U000103a0', '\U000103c3'),
+ ('\U000103c8', '\U000103cf'), ('\U000103d1', '\U000103d5'), ('\U00010400', '\U0001044f'),
+ ('\U00010450', '\U0001049d'), ('\U000104a0', '\U000104a9'), ('\U00010500', '\U00010527'),
+ ('\U00010530', '\U00010563'), ('\U00010600', '\U00010736'), ('\U00010740', '\U00010755'),
+ ('\U00010760', '\U00010767'), ('\U00010800', '\U00010805'), ('\U00010808', '\U00010808'),
+ ('\U0001080a', '\U00010835'), ('\U00010837', '\U00010838'), ('\U0001083c', '\U0001083c'),
+ ('\U0001083f', '\U00010855'), ('\U00010860', '\U00010876'), ('\U00010880', '\U0001089e'),
+ ('\U00010900', '\U00010915'), ('\U00010920', '\U00010939'), ('\U00010980', '\U000109b7'),
+ ('\U000109be', '\U000109bf'), ('\U00010a00', '\U00010a00'), ('\U00010a01', '\U00010a03'),
+ ('\U00010a05', '\U00010a06'), ('\U00010a0c', '\U00010a0f'), ('\U00010a10', '\U00010a13'),
+ ('\U00010a15', '\U00010a17'), ('\U00010a19', '\U00010a33'), ('\U00010a38', '\U00010a3a'),
+ ('\U00010a3f', '\U00010a3f'), ('\U00010a60', '\U00010a7c'), ('\U00010a80', '\U00010a9c'),
+ ('\U00010ac0', '\U00010ac7'), ('\U00010ac9', '\U00010ae4'), ('\U00010ae5', '\U00010ae6'),
+ ('\U00010b00', '\U00010b35'), ('\U00010b40', '\U00010b55'), ('\U00010b60', '\U00010b72'),
+ ('\U00010b80', '\U00010b91'), ('\U00010c00', '\U00010c48'), ('\U00011000', '\U00011000'),
+ ('\U00011001', '\U00011001'), ('\U00011002', '\U00011002'), ('\U00011003', '\U00011037'),
+ ('\U00011038', '\U00011046'), ('\U00011066', '\U0001106f'), ('\U0001107f', '\U00011081'),
+ ('\U00011082', '\U00011082'), ('\U00011083', '\U000110af'), ('\U000110b0', '\U000110b2'),
+ ('\U000110b3', '\U000110b6'), ('\U000110b7', '\U000110b8'), ('\U000110b9', '\U000110ba'),
+ ('\U000110d0', '\U000110e8'), ('\U000110f0', '\U000110f9'), ('\U00011100', '\U00011102'),
+ ('\U00011103', '\U00011126'), ('\U00011127', '\U0001112b'), ('\U0001112c', '\U0001112c'),
+ ('\U0001112d', '\U00011134'), ('\U00011136', '\U0001113f'), ('\U00011150', '\U00011172'),
+ ('\U00011173', '\U00011173'), ('\U00011176', '\U00011176'), ('\U00011180', '\U00011181'),
+ ('\U00011182', '\U00011182'), ('\U00011183', '\U000111b2'), ('\U000111b3', '\U000111b5'),
+ ('\U000111b6', '\U000111be'), ('\U000111bf', '\U000111c0'), ('\U000111c1', '\U000111c4'),
+ ('\U000111d0', '\U000111d9'), ('\U000111da', '\U000111da'), ('\U00011200', '\U00011211'),
+ ('\U00011213', '\U0001122b'), ('\U0001122c', '\U0001122e'), ('\U0001122f', '\U00011231'),
+ ('\U00011232', '\U00011233'), ('\U00011234', '\U00011234'), ('\U00011235', '\U00011235'),
+ ('\U00011236', '\U00011237'), ('\U000112b0', '\U000112de'), ('\U000112df', '\U000112df'),
+ ('\U000112e0', '\U000112e2'), ('\U000112e3', '\U000112ea'), ('\U000112f0', '\U000112f9'),
+ ('\U00011301', '\U00011301'), ('\U00011302', '\U00011303'), ('\U00011305', '\U0001130c'),
+ ('\U0001130f', '\U00011310'), ('\U00011313', '\U00011328'), ('\U0001132a', '\U00011330'),
+ ('\U00011332', '\U00011333'), ('\U00011335', '\U00011339'), ('\U0001133c', '\U0001133c'),
+ ('\U0001133d', '\U0001133d'), ('\U0001133e', '\U0001133f'), ('\U00011340', '\U00011340'),
+ ('\U00011341', '\U00011344'), ('\U00011347', '\U00011348'), ('\U0001134b', '\U0001134d'),
+ ('\U00011357', '\U00011357'), ('\U0001135d', '\U00011361'), ('\U00011362', '\U00011363'),
+ ('\U00011366', '\U0001136c'), ('\U00011370', '\U00011374'), ('\U00011480', '\U000114af'),
+ ('\U000114b0', '\U000114b2'), ('\U000114b3', '\U000114b8'), ('\U000114b9', '\U000114b9'),
+ ('\U000114ba', '\U000114ba'), ('\U000114bb', '\U000114be'), ('\U000114bf', '\U000114c0'),
+ ('\U000114c1', '\U000114c1'), ('\U000114c2', '\U000114c3'), ('\U000114c4', '\U000114c5'),
+ ('\U000114c7', '\U000114c7'), ('\U000114d0', '\U000114d9'), ('\U00011580', '\U000115ae'),
+ ('\U000115af', '\U000115b1'), ('\U000115b2', '\U000115b5'), ('\U000115b8', '\U000115bb'),
+ ('\U000115bc', '\U000115bd'), ('\U000115be', '\U000115be'), ('\U000115bf', '\U000115c0'),
+ ('\U00011600', '\U0001162f'), ('\U00011630', '\U00011632'), ('\U00011633', '\U0001163a'),
+ ('\U0001163b', '\U0001163c'), ('\U0001163d', '\U0001163d'), ('\U0001163e', '\U0001163e'),
+ ('\U0001163f', '\U00011640'), ('\U00011644', '\U00011644'), ('\U00011650', '\U00011659'),
+ ('\U00011680', '\U000116aa'), ('\U000116ab', '\U000116ab'), ('\U000116ac', '\U000116ac'),
+ ('\U000116ad', '\U000116ad'), ('\U000116ae', '\U000116af'), ('\U000116b0', '\U000116b5'),
+ ('\U000116b6', '\U000116b6'), ('\U000116b7', '\U000116b7'), ('\U000116c0', '\U000116c9'),
+ ('\U000118a0', '\U000118df'), ('\U000118e0', '\U000118e9'), ('\U000118ff', '\U000118ff'),
+ ('\U00011ac0', '\U00011af8'), ('\U00012000', '\U00012398'), ('\U00012400', '\U0001246e'),
+ ('\U00013000', '\U0001342e'), ('\U00016800', '\U00016a38'), ('\U00016a40', '\U00016a5e'),
+ ('\U00016a60', '\U00016a69'), ('\U00016ad0', '\U00016aed'), ('\U00016af0', '\U00016af4'),
+ ('\U00016b00', '\U00016b2f'), ('\U00016b30', '\U00016b36'), ('\U00016b40', '\U00016b43'),
+ ('\U00016b50', '\U00016b59'), ('\U00016b63', '\U00016b77'), ('\U00016b7d', '\U00016b8f'),
+ ('\U00016f00', '\U00016f44'), ('\U00016f50', '\U00016f50'), ('\U00016f51', '\U00016f7e'),
+ ('\U00016f8f', '\U00016f92'), ('\U00016f93', '\U00016f9f'), ('\U0001b000', '\U0001b001'),
+ ('\U0001bc00', '\U0001bc6a'), ('\U0001bc70', '\U0001bc7c'), ('\U0001bc80', '\U0001bc88'),
+ ('\U0001bc90', '\U0001bc99'), ('\U0001bc9d', '\U0001bc9e'), ('\U0001d165', '\U0001d166'),
+ ('\U0001d167', '\U0001d169'), ('\U0001d16d', '\U0001d172'), ('\U0001d17b', '\U0001d182'),
+ ('\U0001d185', '\U0001d18b'), ('\U0001d1aa', '\U0001d1ad'), ('\U0001d242', '\U0001d244'),
+ ('\U0001d400', '\U0001d454'), ('\U0001d456', '\U0001d49c'), ('\U0001d49e', '\U0001d49f'),
+ ('\U0001d4a2', '\U0001d4a2'), ('\U0001d4a5', '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'),
+ ('\U0001d4ae', '\U0001d4b9'), ('\U0001d4bb', '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'),
+ ('\U0001d4c5', '\U0001d505'), ('\U0001d507', '\U0001d50a'), ('\U0001d50d', '\U0001d514'),
+ ('\U0001d516', '\U0001d51c'), ('\U0001d51e', '\U0001d539'), ('\U0001d53b', '\U0001d53e'),
+ ('\U0001d540', '\U0001d544'), ('\U0001d546', '\U0001d546'), ('\U0001d54a', '\U0001d550'),
+ ('\U0001d552', '\U0001d6a5'), ('\U0001d6a8', '\U0001d6c0'), ('\U0001d6c2', '\U0001d6da'),
+ ('\U0001d6dc', '\U0001d6fa'), ('\U0001d6fc', '\U0001d714'), ('\U0001d716', '\U0001d734'),
+ ('\U0001d736', '\U0001d74e'), ('\U0001d750', '\U0001d76e'), ('\U0001d770', '\U0001d788'),
+ ('\U0001d78a', '\U0001d7a8'), ('\U0001d7aa', '\U0001d7c2'), ('\U0001d7c4', '\U0001d7cb'),
+ ('\U0001d7ce', '\U0001d7ff'), ('\U0001e800', '\U0001e8c4'), ('\U0001e8d0', '\U0001e8d6'),
+ ('\U0001ee00', '\U0001ee03'), ('\U0001ee05', '\U0001ee1f'), ('\U0001ee21', '\U0001ee22'),
+ ('\U0001ee24', '\U0001ee24'), ('\U0001ee27', '\U0001ee27'), ('\U0001ee29', '\U0001ee32'),
+ ('\U0001ee34', '\U0001ee37'), ('\U0001ee39', '\U0001ee39'), ('\U0001ee3b', '\U0001ee3b'),
+ ('\U0001ee42', '\U0001ee42'), ('\U0001ee47', '\U0001ee47'), ('\U0001ee49', '\U0001ee49'),
+ ('\U0001ee4b', '\U0001ee4b'), ('\U0001ee4d', '\U0001ee4f'), ('\U0001ee51', '\U0001ee52'),
+ ('\U0001ee54', '\U0001ee54'), ('\U0001ee57', '\U0001ee57'), ('\U0001ee59', '\U0001ee59'),
+ ('\U0001ee5b', '\U0001ee5b'), ('\U0001ee5d', '\U0001ee5d'), ('\U0001ee5f', '\U0001ee5f'),
+ ('\U0001ee61', '\U0001ee62'), ('\U0001ee64', '\U0001ee64'), ('\U0001ee67', '\U0001ee6a'),
+ ('\U0001ee6c', '\U0001ee72'), ('\U0001ee74', '\U0001ee77'), ('\U0001ee79', '\U0001ee7c'),
+ ('\U0001ee7e', '\U0001ee7e'), ('\U0001ee80', '\U0001ee89'), ('\U0001ee8b', '\U0001ee9b'),
+ ('\U0001eea1', '\U0001eea3'), ('\U0001eea5', '\U0001eea9'), ('\U0001eeab', '\U0001eebb'),
+ ('\U00020000', '\U0002a6d6'), ('\U0002a700', '\U0002b734'), ('\U0002b740', '\U0002b81d'),
+ ('\U0002f800', '\U0002fa1d'), ('\U000e0100', '\U000e01ef')
+ ];
+
+ pub fn XID_Continue(c: char) -> bool {
+ super::bsearch_range_table(c, XID_Continue_table)
+ }
+
+ pub static XID_Start_table: &'static [(char, char)] = &[
+ ('\x41', '\x5a'), ('\x61', '\x7a'), ('\xaa', '\xaa'), ('\xb5', '\xb5'), ('\xba', '\xba'),
+ ('\xc0', '\xd6'), ('\xd8', '\xf6'), ('\xf8', '\u01ba'), ('\u01bb', '\u01bb'), ('\u01bc',
+ '\u01bf'), ('\u01c0', '\u01c3'), ('\u01c4', '\u0293'), ('\u0294', '\u0294'), ('\u0295',
+ '\u02af'), ('\u02b0', '\u02c1'), ('\u02c6', '\u02d1'), ('\u02e0', '\u02e4'), ('\u02ec',
+ '\u02ec'), ('\u02ee', '\u02ee'), ('\u0370', '\u0373'), ('\u0374', '\u0374'), ('\u0376',
+ '\u0377'), ('\u037b', '\u037d'), ('\u037f', '\u037f'), ('\u0386', '\u0386'), ('\u0388',
+ '\u038a'), ('\u038c', '\u038c'), ('\u038e', '\u03a1'), ('\u03a3', '\u03f5'), ('\u03f7',
+ '\u0481'), ('\u048a', '\u052f'), ('\u0531', '\u0556'), ('\u0559', '\u0559'), ('\u0561',
+ '\u0587'), ('\u05d0', '\u05ea'), ('\u05f0', '\u05f2'), ('\u0620', '\u063f'), ('\u0640',
+ '\u0640'), ('\u0641', '\u064a'), ('\u066e', '\u066f'), ('\u0671', '\u06d3'), ('\u06d5',
+ '\u06d5'), ('\u06e5', '\u06e6'), ('\u06ee', '\u06ef'), ('\u06fa', '\u06fc'), ('\u06ff',
+ '\u06ff'), ('\u0710', '\u0710'), ('\u0712', '\u072f'), ('\u074d', '\u07a5'), ('\u07b1',
+ '\u07b1'), ('\u07ca', '\u07ea'), ('\u07f4', '\u07f5'), ('\u07fa', '\u07fa'), ('\u0800',
+ '\u0815'), ('\u081a', '\u081a'), ('\u0824', '\u0824'), ('\u0828', '\u0828'), ('\u0840',
+ '\u0858'), ('\u08a0', '\u08b2'), ('\u0904', '\u0939'), ('\u093d', '\u093d'), ('\u0950',
+ '\u0950'), ('\u0958', '\u0961'), ('\u0971', '\u0971'), ('\u0972', '\u0980'), ('\u0985',
+ '\u098c'), ('\u098f', '\u0990'), ('\u0993', '\u09a8'), ('\u09aa', '\u09b0'), ('\u09b2',
+ '\u09b2'), ('\u09b6', '\u09b9'), ('\u09bd', '\u09bd'), ('\u09ce', '\u09ce'), ('\u09dc',
+ '\u09dd'), ('\u09df', '\u09e1'), ('\u09f0', '\u09f1'), ('\u0a05', '\u0a0a'), ('\u0a0f',
+ '\u0a10'), ('\u0a13', '\u0a28'), ('\u0a2a', '\u0a30'), ('\u0a32', '\u0a33'), ('\u0a35',
+ '\u0a36'), ('\u0a38', '\u0a39'), ('\u0a59', '\u0a5c'), ('\u0a5e', '\u0a5e'), ('\u0a72',
+ '\u0a74'), ('\u0a85', '\u0a8d'), ('\u0a8f', '\u0a91'), ('\u0a93', '\u0aa8'), ('\u0aaa',
+ '\u0ab0'), ('\u0ab2', '\u0ab3'), ('\u0ab5', '\u0ab9'), ('\u0abd', '\u0abd'), ('\u0ad0',
+ '\u0ad0'), ('\u0ae0', '\u0ae1'), ('\u0b05', '\u0b0c'), ('\u0b0f', '\u0b10'), ('\u0b13',
+ '\u0b28'), ('\u0b2a', '\u0b30'), ('\u0b32', '\u0b33'), ('\u0b35', '\u0b39'), ('\u0b3d',
+ '\u0b3d'), ('\u0b5c', '\u0b5d'), ('\u0b5f', '\u0b61'), ('\u0b71', '\u0b71'), ('\u0b83',
+ '\u0b83'), ('\u0b85', '\u0b8a'), ('\u0b8e', '\u0b90'), ('\u0b92', '\u0b95'), ('\u0b99',
+ '\u0b9a'), ('\u0b9c', '\u0b9c'), ('\u0b9e', '\u0b9f'), ('\u0ba3', '\u0ba4'), ('\u0ba8',
+ '\u0baa'), ('\u0bae', '\u0bb9'), ('\u0bd0', '\u0bd0'), ('\u0c05', '\u0c0c'), ('\u0c0e',
+ '\u0c10'), ('\u0c12', '\u0c28'), ('\u0c2a', '\u0c39'), ('\u0c3d', '\u0c3d'), ('\u0c58',
+ '\u0c59'), ('\u0c60', '\u0c61'), ('\u0c85', '\u0c8c'), ('\u0c8e', '\u0c90'), ('\u0c92',
+ '\u0ca8'), ('\u0caa', '\u0cb3'), ('\u0cb5', '\u0cb9'), ('\u0cbd', '\u0cbd'), ('\u0cde',
+ '\u0cde'), ('\u0ce0', '\u0ce1'), ('\u0cf1', '\u0cf2'), ('\u0d05', '\u0d0c'), ('\u0d0e',
+ '\u0d10'), ('\u0d12', '\u0d3a'), ('\u0d3d', '\u0d3d'), ('\u0d4e', '\u0d4e'), ('\u0d60',
+ '\u0d61'), ('\u0d7a', '\u0d7f'), ('\u0d85', '\u0d96'), ('\u0d9a', '\u0db1'), ('\u0db3',
+ '\u0dbb'), ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'), ('\u0e01', '\u0e30'), ('\u0e32',
+ '\u0e32'), ('\u0e40', '\u0e45'), ('\u0e46', '\u0e46'), ('\u0e81', '\u0e82'), ('\u0e84',
+ '\u0e84'), ('\u0e87', '\u0e88'), ('\u0e8a', '\u0e8a'), ('\u0e8d', '\u0e8d'), ('\u0e94',
+ '\u0e97'), ('\u0e99', '\u0e9f'), ('\u0ea1', '\u0ea3'), ('\u0ea5', '\u0ea5'), ('\u0ea7',
+ '\u0ea7'), ('\u0eaa', '\u0eab'), ('\u0ead', '\u0eb0'), ('\u0eb2', '\u0eb2'), ('\u0ebd',
+ '\u0ebd'), ('\u0ec0', '\u0ec4'), ('\u0ec6', '\u0ec6'), ('\u0edc', '\u0edf'), ('\u0f00',
+ '\u0f00'), ('\u0f40', '\u0f47'), ('\u0f49', '\u0f6c'), ('\u0f88', '\u0f8c'), ('\u1000',
+ '\u102a'), ('\u103f', '\u103f'), ('\u1050', '\u1055'), ('\u105a', '\u105d'), ('\u1061',
+ '\u1061'), ('\u1065', '\u1066'), ('\u106e', '\u1070'), ('\u1075', '\u1081'), ('\u108e',
+ '\u108e'), ('\u10a0', '\u10c5'), ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'), ('\u10d0',
+ '\u10fa'), ('\u10fc', '\u10fc'), ('\u10fd', '\u1248'), ('\u124a', '\u124d'), ('\u1250',
+ '\u1256'), ('\u1258', '\u1258'), ('\u125a', '\u125d'), ('\u1260', '\u1288'), ('\u128a',
+ '\u128d'), ('\u1290', '\u12b0'), ('\u12b2', '\u12b5'), ('\u12b8', '\u12be'), ('\u12c0',
+ '\u12c0'), ('\u12c2', '\u12c5'), ('\u12c8', '\u12d6'), ('\u12d8', '\u1310'), ('\u1312',
+ '\u1315'), ('\u1318', '\u135a'), ('\u1380', '\u138f'), ('\u13a0', '\u13f4'), ('\u1401',
+ '\u166c'), ('\u166f', '\u167f'), ('\u1681', '\u169a'), ('\u16a0', '\u16ea'), ('\u16ee',
+ '\u16f0'), ('\u16f1', '\u16f8'), ('\u1700', '\u170c'), ('\u170e', '\u1711'), ('\u1720',
+ '\u1731'), ('\u1740', '\u1751'), ('\u1760', '\u176c'), ('\u176e', '\u1770'), ('\u1780',
+ '\u17b3'), ('\u17d7', '\u17d7'), ('\u17dc', '\u17dc'), ('\u1820', '\u1842'), ('\u1843',
+ '\u1843'), ('\u1844', '\u1877'), ('\u1880', '\u18a8'), ('\u18aa', '\u18aa'), ('\u18b0',
+ '\u18f5'), ('\u1900', '\u191e'), ('\u1950', '\u196d'), ('\u1970', '\u1974'), ('\u1980',
+ '\u19ab'), ('\u19c1', '\u19c7'), ('\u1a00', '\u1a16'), ('\u1a20', '\u1a54'), ('\u1aa7',
+ '\u1aa7'), ('\u1b05', '\u1b33'), ('\u1b45', '\u1b4b'), ('\u1b83', '\u1ba0'), ('\u1bae',
+ '\u1baf'), ('\u1bba', '\u1be5'), ('\u1c00', '\u1c23'), ('\u1c4d', '\u1c4f'), ('\u1c5a',
+ '\u1c77'), ('\u1c78', '\u1c7d'), ('\u1ce9', '\u1cec'), ('\u1cee', '\u1cf1'), ('\u1cf5',
+ '\u1cf6'), ('\u1d00', '\u1d2b'), ('\u1d2c', '\u1d6a'), ('\u1d6b', '\u1d77'), ('\u1d78',
+ '\u1d78'), ('\u1d79', '\u1d9a'), ('\u1d9b', '\u1dbf'), ('\u1e00', '\u1f15'), ('\u1f18',
+ '\u1f1d'), ('\u1f20', '\u1f45'), ('\u1f48', '\u1f4d'), ('\u1f50', '\u1f57'), ('\u1f59',
+ '\u1f59'), ('\u1f5b', '\u1f5b'), ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f7d'), ('\u1f80',
+ '\u1fb4'), ('\u1fb6', '\u1fbc'), ('\u1fbe', '\u1fbe'), ('\u1fc2', '\u1fc4'), ('\u1fc6',
+ '\u1fcc'), ('\u1fd0', '\u1fd3'), ('\u1fd6', '\u1fdb'), ('\u1fe0', '\u1fec'), ('\u1ff2',
+ '\u1ff4'), ('\u1ff6', '\u1ffc'), ('\u2071', '\u2071'), ('\u207f', '\u207f'), ('\u2090',
+ '\u209c'), ('\u2102', '\u2102'), ('\u2107', '\u2107'), ('\u210a', '\u2113'), ('\u2115',
+ '\u2115'), ('\u2118', '\u2118'), ('\u2119', '\u211d'), ('\u2124', '\u2124'), ('\u2126',
+ '\u2126'), ('\u2128', '\u2128'), ('\u212a', '\u212d'), ('\u212e', '\u212e'), ('\u212f',
+ '\u2134'), ('\u2135', '\u2138'), ('\u2139', '\u2139'), ('\u213c', '\u213f'), ('\u2145',
+ '\u2149'), ('\u214e', '\u214e'), ('\u2160', '\u2182'), ('\u2183', '\u2184'), ('\u2185',
+ '\u2188'), ('\u2c00', '\u2c2e'), ('\u2c30', '\u2c5e'), ('\u2c60', '\u2c7b'), ('\u2c7c',
+ '\u2c7d'), ('\u2c7e', '\u2ce4'), ('\u2ceb', '\u2cee'), ('\u2cf2', '\u2cf3'), ('\u2d00',
+ '\u2d25'), ('\u2d27', '\u2d27'), ('\u2d2d', '\u2d2d'), ('\u2d30', '\u2d67'), ('\u2d6f',
+ '\u2d6f'), ('\u2d80', '\u2d96'), ('\u2da0', '\u2da6'), ('\u2da8', '\u2dae'), ('\u2db0',
+ '\u2db6'), ('\u2db8', '\u2dbe'), ('\u2dc0', '\u2dc6'), ('\u2dc8', '\u2dce'), ('\u2dd0',
+ '\u2dd6'), ('\u2dd8', '\u2dde'), ('\u3005', '\u3005'), ('\u3006', '\u3006'), ('\u3007',
+ '\u3007'), ('\u3021', '\u3029'), ('\u3031', '\u3035'), ('\u3038', '\u303a'), ('\u303b',
+ '\u303b'), ('\u303c', '\u303c'), ('\u3041', '\u3096'), ('\u309d', '\u309e'), ('\u309f',
+ '\u309f'), ('\u30a1', '\u30fa'), ('\u30fc', '\u30fe'), ('\u30ff', '\u30ff'), ('\u3105',
+ '\u312d'), ('\u3131', '\u318e'), ('\u31a0', '\u31ba'), ('\u31f0', '\u31ff'), ('\u3400',
+ '\u4db5'), ('\u4e00', '\u9fcc'), ('\ua000', '\ua014'), ('\ua015', '\ua015'), ('\ua016',
+ '\ua48c'), ('\ua4d0', '\ua4f7'), ('\ua4f8', '\ua4fd'), ('\ua500', '\ua60b'), ('\ua60c',
+ '\ua60c'), ('\ua610', '\ua61f'), ('\ua62a', '\ua62b'), ('\ua640', '\ua66d'), ('\ua66e',
+ '\ua66e'), ('\ua67f', '\ua67f'), ('\ua680', '\ua69b'), ('\ua69c', '\ua69d'), ('\ua6a0',
+ '\ua6e5'), ('\ua6e6', '\ua6ef'), ('\ua717', '\ua71f'), ('\ua722', '\ua76f'), ('\ua770',
+ '\ua770'), ('\ua771', '\ua787'), ('\ua788', '\ua788'), ('\ua78b', '\ua78e'), ('\ua790',
+ '\ua7ad'), ('\ua7b0', '\ua7b1'), ('\ua7f7', '\ua7f7'), ('\ua7f8', '\ua7f9'), ('\ua7fa',
+ '\ua7fa'), ('\ua7fb', '\ua801'), ('\ua803', '\ua805'), ('\ua807', '\ua80a'), ('\ua80c',
+ '\ua822'), ('\ua840', '\ua873'), ('\ua882', '\ua8b3'), ('\ua8f2', '\ua8f7'), ('\ua8fb',
+ '\ua8fb'), ('\ua90a', '\ua925'), ('\ua930', '\ua946'), ('\ua960', '\ua97c'), ('\ua984',
+ '\ua9b2'), ('\ua9cf', '\ua9cf'), ('\ua9e0', '\ua9e4'), ('\ua9e6', '\ua9e6'), ('\ua9e7',
+ '\ua9ef'), ('\ua9fa', '\ua9fe'), ('\uaa00', '\uaa28'), ('\uaa40', '\uaa42'), ('\uaa44',
+ '\uaa4b'), ('\uaa60', '\uaa6f'), ('\uaa70', '\uaa70'), ('\uaa71', '\uaa76'), ('\uaa7a',
+ '\uaa7a'), ('\uaa7e', '\uaaaf'), ('\uaab1', '\uaab1'), ('\uaab5', '\uaab6'), ('\uaab9',
+ '\uaabd'), ('\uaac0', '\uaac0'), ('\uaac2', '\uaac2'), ('\uaadb', '\uaadc'), ('\uaadd',
+ '\uaadd'), ('\uaae0', '\uaaea'), ('\uaaf2', '\uaaf2'), ('\uaaf3', '\uaaf4'), ('\uab01',
+ '\uab06'), ('\uab09', '\uab0e'), ('\uab11', '\uab16'), ('\uab20', '\uab26'), ('\uab28',
+ '\uab2e'), ('\uab30', '\uab5a'), ('\uab5c', '\uab5f'), ('\uab64', '\uab65'), ('\uabc0',
+ '\uabe2'), ('\uac00', '\ud7a3'), ('\ud7b0', '\ud7c6'), ('\ud7cb', '\ud7fb'), ('\uf900',
+ '\ufa6d'), ('\ufa70', '\ufad9'), ('\ufb00', '\ufb06'), ('\ufb13', '\ufb17'), ('\ufb1d',
+ '\ufb1d'), ('\ufb1f', '\ufb28'), ('\ufb2a', '\ufb36'), ('\ufb38', '\ufb3c'), ('\ufb3e',
+ '\ufb3e'), ('\ufb40', '\ufb41'), ('\ufb43', '\ufb44'), ('\ufb46', '\ufbb1'), ('\ufbd3',
+ '\ufc5d'), ('\ufc64', '\ufd3d'), ('\ufd50', '\ufd8f'), ('\ufd92', '\ufdc7'), ('\ufdf0',
+ '\ufdf9'), ('\ufe71', '\ufe71'), ('\ufe73', '\ufe73'), ('\ufe77', '\ufe77'), ('\ufe79',
+ '\ufe79'), ('\ufe7b', '\ufe7b'), ('\ufe7d', '\ufe7d'), ('\ufe7f', '\ufefc'), ('\uff21',
+ '\uff3a'), ('\uff41', '\uff5a'), ('\uff66', '\uff6f'), ('\uff70', '\uff70'), ('\uff71',
+ '\uff9d'), ('\uffa0', '\uffbe'), ('\uffc2', '\uffc7'), ('\uffca', '\uffcf'), ('\uffd2',
+ '\uffd7'), ('\uffda', '\uffdc'), ('\U00010000', '\U0001000b'), ('\U0001000d', '\U00010026'),
+ ('\U00010028', '\U0001003a'), ('\U0001003c', '\U0001003d'), ('\U0001003f', '\U0001004d'),
+ ('\U00010050', '\U0001005d'), ('\U00010080', '\U000100fa'), ('\U00010140', '\U00010174'),
+ ('\U00010280', '\U0001029c'), ('\U000102a0', '\U000102d0'), ('\U00010300', '\U0001031f'),
+ ('\U00010330', '\U00010340'), ('\U00010341', '\U00010341'), ('\U00010342', '\U00010349'),
+ ('\U0001034a', '\U0001034a'), ('\U00010350', '\U00010375'), ('\U00010380', '\U0001039d'),
+ ('\U000103a0', '\U000103c3'), ('\U000103c8', '\U000103cf'), ('\U000103d1', '\U000103d5'),
+ ('\U00010400', '\U0001044f'), ('\U00010450', '\U0001049d'), ('\U00010500', '\U00010527'),
+ ('\U00010530', '\U00010563'), ('\U00010600', '\U00010736'), ('\U00010740', '\U00010755'),
+ ('\U00010760', '\U00010767'), ('\U00010800', '\U00010805'), ('\U00010808', '\U00010808'),
+ ('\U0001080a', '\U00010835'), ('\U00010837', '\U00010838'), ('\U0001083c', '\U0001083c'),
+ ('\U0001083f', '\U00010855'), ('\U00010860', '\U00010876'), ('\U00010880', '\U0001089e'),
+ ('\U00010900', '\U00010915'), ('\U00010920', '\U00010939'), ('\U00010980', '\U000109b7'),
+ ('\U000109be', '\U000109bf'), ('\U00010a00', '\U00010a00'), ('\U00010a10', '\U00010a13'),
+ ('\U00010a15', '\U00010a17'), ('\U00010a19', '\U00010a33'), ('\U00010a60', '\U00010a7c'),
+ ('\U00010a80', '\U00010a9c'), ('\U00010ac0', '\U00010ac7'), ('\U00010ac9', '\U00010ae4'),
+ ('\U00010b00', '\U00010b35'), ('\U00010b40', '\U00010b55'), ('\U00010b60', '\U00010b72'),
+ ('\U00010b80', '\U00010b91'), ('\U00010c00', '\U00010c48'), ('\U00011003', '\U00011037'),
+ ('\U00011083', '\U000110af'), ('\U000110d0', '\U000110e8'), ('\U00011103', '\U00011126'),
+ ('\U00011150', '\U00011172'), ('\U00011176', '\U00011176'), ('\U00011183', '\U000111b2'),
+ ('\U000111c1', '\U000111c4'), ('\U000111da', '\U000111da'), ('\U00011200', '\U00011211'),
+ ('\U00011213', '\U0001122b'), ('\U000112b0', '\U000112de'), ('\U00011305', '\U0001130c'),
+ ('\U0001130f', '\U00011310'), ('\U00011313', '\U00011328'), ('\U0001132a', '\U00011330'),
+ ('\U00011332', '\U00011333'), ('\U00011335', '\U00011339'), ('\U0001133d', '\U0001133d'),
+ ('\U0001135d', '\U00011361'), ('\U00011480', '\U000114af'), ('\U000114c4', '\U000114c5'),
+ ('\U000114c7', '\U000114c7'), ('\U00011580', '\U000115ae'), ('\U00011600', '\U0001162f'),
+ ('\U00011644', '\U00011644'), ('\U00011680', '\U000116aa'), ('\U000118a0', '\U000118df'),
+ ('\U000118ff', '\U000118ff'), ('\U00011ac0', '\U00011af8'), ('\U00012000', '\U00012398'),
+ ('\U00012400', '\U0001246e'), ('\U00013000', '\U0001342e'), ('\U00016800', '\U00016a38'),
+ ('\U00016a40', '\U00016a5e'), ('\U00016ad0', '\U00016aed'), ('\U00016b00', '\U00016b2f'),
+ ('\U00016b40', '\U00016b43'), ('\U00016b63', '\U00016b77'), ('\U00016b7d', '\U00016b8f'),
+ ('\U00016f00', '\U00016f44'), ('\U00016f50', '\U00016f50'), ('\U00016f93', '\U00016f9f'),
+ ('\U0001b000', '\U0001b001'), ('\U0001bc00', '\U0001bc6a'), ('\U0001bc70', '\U0001bc7c'),
+ ('\U0001bc80', '\U0001bc88'), ('\U0001bc90', '\U0001bc99'), ('\U0001d400', '\U0001d454'),
+ ('\U0001d456', '\U0001d49c'), ('\U0001d49e', '\U0001d49f'), ('\U0001d4a2', '\U0001d4a2'),
+ ('\U0001d4a5', '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'), ('\U0001d4ae', '\U0001d4b9'),
+ ('\U0001d4bb', '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5', '\U0001d505'),
+ ('\U0001d507', '\U0001d50a'), ('\U0001d50d', '\U0001d514'), ('\U0001d516', '\U0001d51c'),
+ ('\U0001d51e', '\U0001d539'), ('\U0001d53b', '\U0001d53e'), ('\U0001d540', '\U0001d544'),
+ ('\U0001d546', '\U0001d546'), ('\U0001d54a', '\U0001d550'), ('\U0001d552', '\U0001d6a5'),
+ ('\U0001d6a8', '\U0001d6c0'), ('\U0001d6c2', '\U0001d6da'), ('\U0001d6dc', '\U0001d6fa'),
+ ('\U0001d6fc', '\U0001d714'), ('\U0001d716', '\U0001d734'), ('\U0001d736', '\U0001d74e'),
+ ('\U0001d750', '\U0001d76e'), ('\U0001d770', '\U0001d788'), ('\U0001d78a', '\U0001d7a8'),
+ ('\U0001d7aa', '\U0001d7c2'), ('\U0001d7c4', '\U0001d7cb'), ('\U0001e800', '\U0001e8c4'),
+ ('\U0001ee00', '\U0001ee03'), ('\U0001ee05', '\U0001ee1f'), ('\U0001ee21', '\U0001ee22'),
+ ('\U0001ee24', '\U0001ee24'), ('\U0001ee27', '\U0001ee27'), ('\U0001ee29', '\U0001ee32'),
+ ('\U0001ee34', '\U0001ee37'), ('\U0001ee39', '\U0001ee39'), ('\U0001ee3b', '\U0001ee3b'),
+ ('\U0001ee42', '\U0001ee42'), ('\U0001ee47', '\U0001ee47'), ('\U0001ee49', '\U0001ee49'),
+ ('\U0001ee4b', '\U0001ee4b'), ('\U0001ee4d', '\U0001ee4f'), ('\U0001ee51', '\U0001ee52'),
+ ('\U0001ee54', '\U0001ee54'), ('\U0001ee57', '\U0001ee57'), ('\U0001ee59', '\U0001ee59'),
+ ('\U0001ee5b', '\U0001ee5b'), ('\U0001ee5d', '\U0001ee5d'), ('\U0001ee5f', '\U0001ee5f'),
+ ('\U0001ee61', '\U0001ee62'), ('\U0001ee64', '\U0001ee64'), ('\U0001ee67', '\U0001ee6a'),
+ ('\U0001ee6c', '\U0001ee72'), ('\U0001ee74', '\U0001ee77'), ('\U0001ee79', '\U0001ee7c'),
+ ('\U0001ee7e', '\U0001ee7e'), ('\U0001ee80', '\U0001ee89'), ('\U0001ee8b', '\U0001ee9b'),
+ ('\U0001eea1', '\U0001eea3'), ('\U0001eea5', '\U0001eea9'), ('\U0001eeab', '\U0001eebb'),
+ ('\U00020000', '\U0002a6d6'), ('\U0002a700', '\U0002b734'), ('\U0002b740', '\U0002b81d'),
+ ('\U0002f800', '\U0002fa1d')
+ ];
+
+ pub fn XID_Start(c: char) -> bool {
+ super::bsearch_range_table(c, XID_Start_table)
+ }
+
+}
+
+pub mod script {
+ pub static Arabic_table: &'static [(char, char)] = &[
+ ('\u0600', '\u0604'), ('\u0606', '\u0608'), ('\u0609', '\u060a'), ('\u060b', '\u060b'),
+ ('\u060d', '\u060d'), ('\u060e', '\u060f'), ('\u0610', '\u061a'), ('\u061e', '\u061e'),
+ ('\u0620', '\u063f'), ('\u0641', '\u064a'), ('\u0656', '\u065f'), ('\u066a', '\u066d'),
+ ('\u066e', '\u066f'), ('\u0671', '\u06d3'), ('\u06d4', '\u06d4'), ('\u06d5', '\u06d5'),
+ ('\u06d6', '\u06dc'), ('\u06de', '\u06de'), ('\u06df', '\u06e4'), ('\u06e5', '\u06e6'),
+ ('\u06e7', '\u06e8'), ('\u06e9', '\u06e9'), ('\u06ea', '\u06ed'), ('\u06ee', '\u06ef'),
+ ('\u06f0', '\u06f9'), ('\u06fa', '\u06fc'), ('\u06fd', '\u06fe'), ('\u06ff', '\u06ff'),
+ ('\u0750', '\u077f'), ('\u08a0', '\u08b2'), ('\u08e4', '\u08ff'), ('\ufb50', '\ufbb1'),
+ ('\ufbb2', '\ufbc1'), ('\ufbd3', '\ufd3d'), ('\ufd50', '\ufd8f'), ('\ufd92', '\ufdc7'),
+ ('\ufdf0', '\ufdfb'), ('\ufdfc', '\ufdfc'), ('\ufdfd', '\ufdfd'), ('\ufe70', '\ufe74'),
+ ('\ufe76', '\ufefc'), ('\U00010e60', '\U00010e7e'), ('\U0001ee00', '\U0001ee03'),
+ ('\U0001ee05', '\U0001ee1f'), ('\U0001ee21', '\U0001ee22'), ('\U0001ee24', '\U0001ee24'),
+ ('\U0001ee27', '\U0001ee27'), ('\U0001ee29', '\U0001ee32'), ('\U0001ee34', '\U0001ee37'),
+ ('\U0001ee39', '\U0001ee39'), ('\U0001ee3b', '\U0001ee3b'), ('\U0001ee42', '\U0001ee42'),
+ ('\U0001ee47', '\U0001ee47'), ('\U0001ee49', '\U0001ee49'), ('\U0001ee4b', '\U0001ee4b'),
+ ('\U0001ee4d', '\U0001ee4f'), ('\U0001ee51', '\U0001ee52'), ('\U0001ee54', '\U0001ee54'),
+ ('\U0001ee57', '\U0001ee57'), ('\U0001ee59', '\U0001ee59'), ('\U0001ee5b', '\U0001ee5b'),
+ ('\U0001ee5d', '\U0001ee5d'), ('\U0001ee5f', '\U0001ee5f'), ('\U0001ee61', '\U0001ee62'),
+ ('\U0001ee64', '\U0001ee64'), ('\U0001ee67', '\U0001ee6a'), ('\U0001ee6c', '\U0001ee72'),
+ ('\U0001ee74', '\U0001ee77'), ('\U0001ee79', '\U0001ee7c'), ('\U0001ee7e', '\U0001ee7e'),
+ ('\U0001ee80', '\U0001ee89'), ('\U0001ee8b', '\U0001ee9b'), ('\U0001eea1', '\U0001eea3'),
+ ('\U0001eea5', '\U0001eea9'), ('\U0001eeab', '\U0001eebb'), ('\U0001eef0', '\U0001eef1')
+ ];
+
+ pub static Armenian_table: &'static [(char, char)] = &[
+ ('\u0531', '\u0556'), ('\u0559', '\u0559'), ('\u055a', '\u055f'), ('\u0561', '\u0587'),
+ ('\u058a', '\u058a'), ('\u058d', '\u058e'), ('\u058f', '\u058f'), ('\ufb13', '\ufb17')
+ ];
+
+ pub static Avestan_table: &'static [(char, char)] = &[
+ ('\U00010b00', '\U00010b35'), ('\U00010b39', '\U00010b3f')
+ ];
+
+ pub static Balinese_table: &'static [(char, char)] = &[
+ ('\u1b00', '\u1b03'), ('\u1b04', '\u1b04'), ('\u1b05', '\u1b33'), ('\u1b34', '\u1b34'),
+ ('\u1b35', '\u1b35'), ('\u1b36', '\u1b3a'), ('\u1b3b', '\u1b3b'), ('\u1b3c', '\u1b3c'),
+ ('\u1b3d', '\u1b41'), ('\u1b42', '\u1b42'), ('\u1b43', '\u1b44'), ('\u1b45', '\u1b4b'),
+ ('\u1b50', '\u1b59'), ('\u1b5a', '\u1b60'), ('\u1b61', '\u1b6a'), ('\u1b6b', '\u1b73'),
+ ('\u1b74', '\u1b7c')
+ ];
+
+ pub static Bamum_table: &'static [(char, char)] = &[
+ ('\ua6a0', '\ua6e5'), ('\ua6e6', '\ua6ef'), ('\ua6f0', '\ua6f1'), ('\ua6f2', '\ua6f7'),
+ ('\U00016800', '\U00016a38')
+ ];
+
+ pub static Bassa_Vah_table: &'static [(char, char)] = &[
+ ('\U00016ad0', '\U00016aed'), ('\U00016af0', '\U00016af4'), ('\U00016af5', '\U00016af5')
+ ];
+
+ pub static Batak_table: &'static [(char, char)] = &[
+ ('\u1bc0', '\u1be5'), ('\u1be6', '\u1be6'), ('\u1be7', '\u1be7'), ('\u1be8', '\u1be9'),
+ ('\u1bea', '\u1bec'), ('\u1bed', '\u1bed'), ('\u1bee', '\u1bee'), ('\u1bef', '\u1bf1'),
+ ('\u1bf2', '\u1bf3'), ('\u1bfc', '\u1bff')
+ ];
+
+ pub static Bengali_table: &'static [(char, char)] = &[
+ ('\u0980', '\u0980'), ('\u0981', '\u0981'), ('\u0982', '\u0983'), ('\u0985', '\u098c'),
+ ('\u098f', '\u0990'), ('\u0993', '\u09a8'), ('\u09aa', '\u09b0'), ('\u09b2', '\u09b2'),
+ ('\u09b6', '\u09b9'), ('\u09bc', '\u09bc'), ('\u09bd', '\u09bd'), ('\u09be', '\u09c0'),
+ ('\u09c1', '\u09c4'), ('\u09c7', '\u09c8'), ('\u09cb', '\u09cc'), ('\u09cd', '\u09cd'),
+ ('\u09ce', '\u09ce'), ('\u09d7', '\u09d7'), ('\u09dc', '\u09dd'), ('\u09df', '\u09e1'),
+ ('\u09e2', '\u09e3'), ('\u09e6', '\u09ef'), ('\u09f0', '\u09f1'), ('\u09f2', '\u09f3'),
+ ('\u09f4', '\u09f9'), ('\u09fa', '\u09fa'), ('\u09fb', '\u09fb')
+ ];
+
+ pub static Bopomofo_table: &'static [(char, char)] = &[
+ ('\u02ea', '\u02eb'), ('\u3105', '\u312d'), ('\u31a0', '\u31ba')
+ ];
+
+ pub static Brahmi_table: &'static [(char, char)] = &[
+ ('\U00011000', '\U00011000'), ('\U00011001', '\U00011001'), ('\U00011002', '\U00011002'),
+ ('\U00011003', '\U00011037'), ('\U00011038', '\U00011046'), ('\U00011047', '\U0001104d'),
+ ('\U00011052', '\U00011065'), ('\U00011066', '\U0001106f'), ('\U0001107f', '\U0001107f')
+ ];
+
+ pub static Braille_table: &'static [(char, char)] = &[
+ ('\u2800', '\u28ff')
+ ];
+
+ pub static Buginese_table: &'static [(char, char)] = &[
+ ('\u1a00', '\u1a16'), ('\u1a17', '\u1a18'), ('\u1a19', '\u1a1a'), ('\u1a1b', '\u1a1b'),
+ ('\u1a1e', '\u1a1f')
+ ];
+
+ pub static Buhid_table: &'static [(char, char)] = &[
+ ('\u1740', '\u1751'), ('\u1752', '\u1753')
+ ];
+
+ pub static Canadian_Aboriginal_table: &'static [(char, char)] = &[
+ ('\u1400', '\u1400'), ('\u1401', '\u166c'), ('\u166d', '\u166e'), ('\u166f', '\u167f'),
+ ('\u18b0', '\u18f5')
+ ];
+
+ pub static Carian_table: &'static [(char, char)] = &[
+ ('\U000102a0', '\U000102d0')
+ ];
+
+ pub static Caucasian_Albanian_table: &'static [(char, char)] = &[
+ ('\U00010530', '\U00010563'), ('\U0001056f', '\U0001056f')
+ ];
+
+ pub static Chakma_table: &'static [(char, char)] = &[
+ ('\U00011100', '\U00011102'), ('\U00011103', '\U00011126'), ('\U00011127', '\U0001112b'),
+ ('\U0001112c', '\U0001112c'), ('\U0001112d', '\U00011134'), ('\U00011136', '\U0001113f'),
+ ('\U00011140', '\U00011143')
+ ];
+
+ pub static Cham_table: &'static [(char, char)] = &[
+ ('\uaa00', '\uaa28'), ('\uaa29', '\uaa2e'), ('\uaa2f', '\uaa30'), ('\uaa31', '\uaa32'),
+ ('\uaa33', '\uaa34'), ('\uaa35', '\uaa36'), ('\uaa40', '\uaa42'), ('\uaa43', '\uaa43'),
+ ('\uaa44', '\uaa4b'), ('\uaa4c', '\uaa4c'), ('\uaa4d', '\uaa4d'), ('\uaa50', '\uaa59'),
+ ('\uaa5c', '\uaa5f')
+ ];
+
+ pub static Cherokee_table: &'static [(char, char)] = &[
+ ('\u13a0', '\u13f4')
+ ];
+
+ pub static Common_table: &'static [(char, char)] = &[
+ ('\x00', '\x1f'), ('\x20', '\x20'), ('\x21', '\x23'), ('\x24', '\x24'), ('\x25', '\x27'),
+ ('\x28', '\x28'), ('\x29', '\x29'), ('\x2a', '\x2a'), ('\x2b', '\x2b'), ('\x2c', '\x2c'),
+ ('\x2d', '\x2d'), ('\x2e', '\x2f'), ('\x30', '\x39'), ('\x3a', '\x3b'), ('\x3c', '\x3e'),
+ ('\x3f', '\x40'), ('\x5b', '\x5b'), ('\x5c', '\x5c'), ('\x5d', '\x5d'), ('\x5e', '\x5e'),
+ ('\x5f', '\x5f'), ('\x60', '\x60'), ('\x7b', '\x7b'), ('\x7c', '\x7c'), ('\x7d', '\x7d'),
+ ('\x7e', '\x7e'), ('\x7f', '\x9f'), ('\xa0', '\xa0'), ('\xa1', '\xa1'), ('\xa2', '\xa5'),
+ ('\xa6', '\xa6'), ('\xa7', '\xa7'), ('\xa8', '\xa8'), ('\xa9', '\xa9'), ('\xab', '\xab'),
+ ('\xac', '\xac'), ('\xad', '\xad'), ('\xae', '\xae'), ('\xaf', '\xaf'), ('\xb0', '\xb0'),
+ ('\xb1', '\xb1'), ('\xb2', '\xb3'), ('\xb4', '\xb4'), ('\xb5', '\xb5'), ('\xb6', '\xb7'),
+ ('\xb8', '\xb8'), ('\xb9', '\xb9'), ('\xbb', '\xbb'), ('\xbc', '\xbe'), ('\xbf', '\xbf'),
+ ('\xd7', '\xd7'), ('\xf7', '\xf7'), ('\u02b9', '\u02c1'), ('\u02c2', '\u02c5'), ('\u02c6',
+ '\u02d1'), ('\u02d2', '\u02df'), ('\u02e5', '\u02e9'), ('\u02ec', '\u02ec'), ('\u02ed',
+ '\u02ed'), ('\u02ee', '\u02ee'), ('\u02ef', '\u02ff'), ('\u0374', '\u0374'), ('\u037e',
+ '\u037e'), ('\u0385', '\u0385'), ('\u0387', '\u0387'), ('\u0589', '\u0589'), ('\u0605',
+ '\u0605'), ('\u060c', '\u060c'), ('\u061b', '\u061b'), ('\u061c', '\u061c'), ('\u061f',
+ '\u061f'), ('\u0640', '\u0640'), ('\u0660', '\u0669'), ('\u06dd', '\u06dd'), ('\u0964',
+ '\u0965'), ('\u0e3f', '\u0e3f'), ('\u0fd5', '\u0fd8'), ('\u10fb', '\u10fb'), ('\u16eb',
+ '\u16ed'), ('\u1735', '\u1736'), ('\u1802', '\u1803'), ('\u1805', '\u1805'), ('\u1cd3',
+ '\u1cd3'), ('\u1ce1', '\u1ce1'), ('\u1ce9', '\u1cec'), ('\u1cee', '\u1cf1'), ('\u1cf2',
+ '\u1cf3'), ('\u1cf5', '\u1cf6'), ('\u2000', '\u200a'), ('\u200b', '\u200b'), ('\u200e',
+ '\u200f'), ('\u2010', '\u2015'), ('\u2016', '\u2017'), ('\u2018', '\u2018'), ('\u2019',
+ '\u2019'), ('\u201a', '\u201a'), ('\u201b', '\u201c'), ('\u201d', '\u201d'), ('\u201e',
+ '\u201e'), ('\u201f', '\u201f'), ('\u2020', '\u2027'), ('\u2028', '\u2028'), ('\u2029',
+ '\u2029'), ('\u202a', '\u202e'), ('\u202f', '\u202f'), ('\u2030', '\u2038'), ('\u2039',
+ '\u2039'), ('\u203a', '\u203a'), ('\u203b', '\u203e'), ('\u203f', '\u2040'), ('\u2041',
+ '\u2043'), ('\u2044', '\u2044'), ('\u2045', '\u2045'), ('\u2046', '\u2046'), ('\u2047',
+ '\u2051'), ('\u2052', '\u2052'), ('\u2053', '\u2053'), ('\u2054', '\u2054'), ('\u2055',
+ '\u205e'), ('\u205f', '\u205f'), ('\u2060', '\u2064'), ('\u2066', '\u206f'), ('\u2070',
+ '\u2070'), ('\u2074', '\u2079'), ('\u207a', '\u207c'), ('\u207d', '\u207d'), ('\u207e',
+ '\u207e'), ('\u2080', '\u2089'), ('\u208a', '\u208c'), ('\u208d', '\u208d'), ('\u208e',
+ '\u208e'), ('\u20a0', '\u20bd'), ('\u2100', '\u2101'), ('\u2102', '\u2102'), ('\u2103',
+ '\u2106'), ('\u2107', '\u2107'), ('\u2108', '\u2109'), ('\u210a', '\u2113'), ('\u2114',
+ '\u2114'), ('\u2115', '\u2115'), ('\u2116', '\u2117'), ('\u2118', '\u2118'), ('\u2119',
+ '\u211d'), ('\u211e', '\u2123'), ('\u2124', '\u2124'), ('\u2125', '\u2125'), ('\u2127',
+ '\u2127'), ('\u2128', '\u2128'), ('\u2129', '\u2129'), ('\u212c', '\u212d'), ('\u212e',
+ '\u212e'), ('\u212f', '\u2131'), ('\u2133', '\u2134'), ('\u2135', '\u2138'), ('\u2139',
+ '\u2139'), ('\u213a', '\u213b'), ('\u213c', '\u213f'), ('\u2140', '\u2144'), ('\u2145',
+ '\u2149'), ('\u214a', '\u214a'), ('\u214b', '\u214b'), ('\u214c', '\u214d'), ('\u214f',
+ '\u214f'), ('\u2150', '\u215f'), ('\u2189', '\u2189'), ('\u2190', '\u2194'), ('\u2195',
+ '\u2199'), ('\u219a', '\u219b'), ('\u219c', '\u219f'), ('\u21a0', '\u21a0'), ('\u21a1',
+ '\u21a2'), ('\u21a3', '\u21a3'), ('\u21a4', '\u21a5'), ('\u21a6', '\u21a6'), ('\u21a7',
+ '\u21ad'), ('\u21ae', '\u21ae'), ('\u21af', '\u21cd'), ('\u21ce', '\u21cf'), ('\u21d0',
+ '\u21d1'), ('\u21d2', '\u21d2'), ('\u21d3', '\u21d3'), ('\u21d4', '\u21d4'), ('\u21d5',
+ '\u21f3'), ('\u21f4', '\u22ff'), ('\u2300', '\u2307'), ('\u2308', '\u2308'), ('\u2309',
+ '\u2309'), ('\u230a', '\u230a'), ('\u230b', '\u230b'), ('\u230c', '\u231f'), ('\u2320',
+ '\u2321'), ('\u2322', '\u2328'), ('\u2329', '\u2329'), ('\u232a', '\u232a'), ('\u232b',
+ '\u237b'), ('\u237c', '\u237c'), ('\u237d', '\u239a'), ('\u239b', '\u23b3'), ('\u23b4',
+ '\u23db'), ('\u23dc', '\u23e1'), ('\u23e2', '\u23fa'), ('\u2400', '\u2426'), ('\u2440',
+ '\u244a'), ('\u2460', '\u249b'), ('\u249c', '\u24e9'), ('\u24ea', '\u24ff'), ('\u2500',
+ '\u25b6'), ('\u25b7', '\u25b7'), ('\u25b8', '\u25c0'), ('\u25c1', '\u25c1'), ('\u25c2',
+ '\u25f7'), ('\u25f8', '\u25ff'), ('\u2600', '\u266e'), ('\u266f', '\u266f'), ('\u2670',
+ '\u2767'), ('\u2768', '\u2768'), ('\u2769', '\u2769'), ('\u276a', '\u276a'), ('\u276b',
+ '\u276b'), ('\u276c', '\u276c'), ('\u276d', '\u276d'), ('\u276e', '\u276e'), ('\u276f',
+ '\u276f'), ('\u2770', '\u2770'), ('\u2771', '\u2771'), ('\u2772', '\u2772'), ('\u2773',
+ '\u2773'), ('\u2774', '\u2774'), ('\u2775', '\u2775'), ('\u2776', '\u2793'), ('\u2794',
+ '\u27bf'), ('\u27c0', '\u27c4'), ('\u27c5', '\u27c5'), ('\u27c6', '\u27c6'), ('\u27c7',
+ '\u27e5'), ('\u27e6', '\u27e6'), ('\u27e7', '\u27e7'), ('\u27e8', '\u27e8'), ('\u27e9',
+ '\u27e9'), ('\u27ea', '\u27ea'), ('\u27eb', '\u27eb'), ('\u27ec', '\u27ec'), ('\u27ed',
+ '\u27ed'), ('\u27ee', '\u27ee'), ('\u27ef', '\u27ef'), ('\u27f0', '\u27ff'), ('\u2900',
+ '\u2982'), ('\u2983', '\u2983'), ('\u2984', '\u2984'), ('\u2985', '\u2985'), ('\u2986',
+ '\u2986'), ('\u2987', '\u2987'), ('\u2988', '\u2988'), ('\u2989', '\u2989'), ('\u298a',
+ '\u298a'), ('\u298b', '\u298b'), ('\u298c', '\u298c'), ('\u298d', '\u298d'), ('\u298e',
+ '\u298e'), ('\u298f', '\u298f'), ('\u2990', '\u2990'), ('\u2991', '\u2991'), ('\u2992',
+ '\u2992'), ('\u2993', '\u2993'), ('\u2994', '\u2994'), ('\u2995', '\u2995'), ('\u2996',
+ '\u2996'), ('\u2997', '\u2997'), ('\u2998', '\u2998'), ('\u2999', '\u29d7'), ('\u29d8',
+ '\u29d8'), ('\u29d9', '\u29d9'), ('\u29da', '\u29da'), ('\u29db', '\u29db'), ('\u29dc',
+ '\u29fb'), ('\u29fc', '\u29fc'), ('\u29fd', '\u29fd'), ('\u29fe', '\u2aff'), ('\u2b00',
+ '\u2b2f'), ('\u2b30', '\u2b44'), ('\u2b45', '\u2b46'), ('\u2b47', '\u2b4c'), ('\u2b4d',
+ '\u2b73'), ('\u2b76', '\u2b95'), ('\u2b98', '\u2bb9'), ('\u2bbd', '\u2bc8'), ('\u2bca',
+ '\u2bd1'), ('\u2e00', '\u2e01'), ('\u2e02', '\u2e02'), ('\u2e03', '\u2e03'), ('\u2e04',
+ '\u2e04'), ('\u2e05', '\u2e05'), ('\u2e06', '\u2e08'), ('\u2e09', '\u2e09'), ('\u2e0a',
+ '\u2e0a'), ('\u2e0b', '\u2e0b'), ('\u2e0c', '\u2e0c'), ('\u2e0d', '\u2e0d'), ('\u2e0e',
+ '\u2e16'), ('\u2e17', '\u2e17'), ('\u2e18', '\u2e19'), ('\u2e1a', '\u2e1a'), ('\u2e1b',
+ '\u2e1b'), ('\u2e1c', '\u2e1c'), ('\u2e1d', '\u2e1d'), ('\u2e1e', '\u2e1f'), ('\u2e20',
+ '\u2e20'), ('\u2e21', '\u2e21'), ('\u2e22', '\u2e22'), ('\u2e23', '\u2e23'), ('\u2e24',
+ '\u2e24'), ('\u2e25', '\u2e25'), ('\u2e26', '\u2e26'), ('\u2e27', '\u2e27'), ('\u2e28',
+ '\u2e28'), ('\u2e29', '\u2e29'), ('\u2e2a', '\u2e2e'), ('\u2e2f', '\u2e2f'), ('\u2e30',
+ '\u2e39'), ('\u2e3a', '\u2e3b'), ('\u2e3c', '\u2e3f'), ('\u2e40', '\u2e40'), ('\u2e41',
+ '\u2e41'), ('\u2e42', '\u2e42'), ('\u2ff0', '\u2ffb'), ('\u3000', '\u3000'), ('\u3001',
+ '\u3003'), ('\u3004', '\u3004'), ('\u3006', '\u3006'), ('\u3008', '\u3008'), ('\u3009',
+ '\u3009'), ('\u300a', '\u300a'), ('\u300b', '\u300b'), ('\u300c', '\u300c'), ('\u300d',
+ '\u300d'), ('\u300e', '\u300e'), ('\u300f', '\u300f'), ('\u3010', '\u3010'), ('\u3011',
+ '\u3011'), ('\u3012', '\u3013'), ('\u3014', '\u3014'), ('\u3015', '\u3015'), ('\u3016',
+ '\u3016'), ('\u3017', '\u3017'), ('\u3018', '\u3018'), ('\u3019', '\u3019'), ('\u301a',
+ '\u301a'), ('\u301b', '\u301b'), ('\u301c', '\u301c'), ('\u301d', '\u301d'), ('\u301e',
+ '\u301f'), ('\u3020', '\u3020'), ('\u3030', '\u3030'), ('\u3031', '\u3035'), ('\u3036',
+ '\u3037'), ('\u303c', '\u303c'), ('\u303d', '\u303d'), ('\u303e', '\u303f'), ('\u309b',
+ '\u309c'), ('\u30a0', '\u30a0'), ('\u30fb', '\u30fb'), ('\u30fc', '\u30fc'), ('\u3190',
+ '\u3191'), ('\u3192', '\u3195'), ('\u3196', '\u319f'), ('\u31c0', '\u31e3'), ('\u3220',
+ '\u3229'), ('\u322a', '\u3247'), ('\u3248', '\u324f'), ('\u3250', '\u3250'), ('\u3251',
+ '\u325f'), ('\u327f', '\u327f'), ('\u3280', '\u3289'), ('\u328a', '\u32b0'), ('\u32b1',
+ '\u32bf'), ('\u32c0', '\u32cf'), ('\u3358', '\u33ff'), ('\u4dc0', '\u4dff'), ('\ua700',
+ '\ua716'), ('\ua717', '\ua71f'), ('\ua720', '\ua721'), ('\ua788', '\ua788'), ('\ua789',
+ '\ua78a'), ('\ua830', '\ua835'), ('\ua836', '\ua837'), ('\ua838', '\ua838'), ('\ua839',
+ '\ua839'), ('\ua92e', '\ua92e'), ('\ua9cf', '\ua9cf'), ('\uab5b', '\uab5b'), ('\ufd3e',
+ '\ufd3e'), ('\ufd3f', '\ufd3f'), ('\ufe10', '\ufe16'), ('\ufe17', '\ufe17'), ('\ufe18',
+ '\ufe18'), ('\ufe19', '\ufe19'), ('\ufe30', '\ufe30'), ('\ufe31', '\ufe32'), ('\ufe33',
+ '\ufe34'), ('\ufe35', '\ufe35'), ('\ufe36', '\ufe36'), ('\ufe37', '\ufe37'), ('\ufe38',
+ '\ufe38'), ('\ufe39', '\ufe39'), ('\ufe3a', '\ufe3a'), ('\ufe3b', '\ufe3b'), ('\ufe3c',
+ '\ufe3c'), ('\ufe3d', '\ufe3d'), ('\ufe3e', '\ufe3e'), ('\ufe3f', '\ufe3f'), ('\ufe40',
+ '\ufe40'), ('\ufe41', '\ufe41'), ('\ufe42', '\ufe42'), ('\ufe43', '\ufe43'), ('\ufe44',
+ '\ufe44'), ('\ufe45', '\ufe46'), ('\ufe47', '\ufe47'), ('\ufe48', '\ufe48'), ('\ufe49',
+ '\ufe4c'), ('\ufe4d', '\ufe4f'), ('\ufe50', '\ufe52'), ('\ufe54', '\ufe57'), ('\ufe58',
+ '\ufe58'), ('\ufe59', '\ufe59'), ('\ufe5a', '\ufe5a'), ('\ufe5b', '\ufe5b'), ('\ufe5c',
+ '\ufe5c'), ('\ufe5d', '\ufe5d'), ('\ufe5e', '\ufe5e'), ('\ufe5f', '\ufe61'), ('\ufe62',
+ '\ufe62'), ('\ufe63', '\ufe63'), ('\ufe64', '\ufe66'), ('\ufe68', '\ufe68'), ('\ufe69',
+ '\ufe69'), ('\ufe6a', '\ufe6b'), ('\ufeff', '\ufeff'), ('\uff01', '\uff03'), ('\uff04',
+ '\uff04'), ('\uff05', '\uff07'), ('\uff08', '\uff08'), ('\uff09', '\uff09'), ('\uff0a',
+ '\uff0a'), ('\uff0b', '\uff0b'), ('\uff0c', '\uff0c'), ('\uff0d', '\uff0d'), ('\uff0e',
+ '\uff0f'), ('\uff10', '\uff19'), ('\uff1a', '\uff1b'), ('\uff1c', '\uff1e'), ('\uff1f',
+ '\uff20'), ('\uff3b', '\uff3b'), ('\uff3c', '\uff3c'), ('\uff3d', '\uff3d'), ('\uff3e',
+ '\uff3e'), ('\uff3f', '\uff3f'), ('\uff40', '\uff40'), ('\uff5b', '\uff5b'), ('\uff5c',
+ '\uff5c'), ('\uff5d', '\uff5d'), ('\uff5e', '\uff5e'), ('\uff5f', '\uff5f'), ('\uff60',
+ '\uff60'), ('\uff61', '\uff61'), ('\uff62', '\uff62'), ('\uff63', '\uff63'), ('\uff64',
+ '\uff65'), ('\uff70', '\uff70'), ('\uff9e', '\uff9f'), ('\uffe0', '\uffe1'), ('\uffe2',
+ '\uffe2'), ('\uffe3', '\uffe3'), ('\uffe4', '\uffe4'), ('\uffe5', '\uffe6'), ('\uffe8',
+ '\uffe8'), ('\uffe9', '\uffec'), ('\uffed', '\uffee'), ('\ufff9', '\ufffb'), ('\ufffc',
+ '\ufffd'), ('\U00010100', '\U00010102'), ('\U00010107', '\U00010133'), ('\U00010137',
+ '\U0001013f'), ('\U00010190', '\U0001019b'), ('\U000101d0', '\U000101fc'), ('\U000102e1',
+ '\U000102fb'), ('\U0001bca0', '\U0001bca3'), ('\U0001d000', '\U0001d0f5'), ('\U0001d100',
+ '\U0001d126'), ('\U0001d129', '\U0001d164'), ('\U0001d165', '\U0001d166'), ('\U0001d16a',
+ '\U0001d16c'), ('\U0001d16d', '\U0001d172'), ('\U0001d173', '\U0001d17a'), ('\U0001d183',
+ '\U0001d184'), ('\U0001d18c', '\U0001d1a9'), ('\U0001d1ae', '\U0001d1dd'), ('\U0001d300',
+ '\U0001d356'), ('\U0001d360', '\U0001d371'), ('\U0001d400', '\U0001d454'), ('\U0001d456',
+ '\U0001d49c'), ('\U0001d49e', '\U0001d49f'), ('\U0001d4a2', '\U0001d4a2'), ('\U0001d4a5',
+ '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'), ('\U0001d4ae', '\U0001d4b9'), ('\U0001d4bb',
+ '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5', '\U0001d505'), ('\U0001d507',
+ '\U0001d50a'), ('\U0001d50d', '\U0001d514'), ('\U0001d516', '\U0001d51c'), ('\U0001d51e',
+ '\U0001d539'), ('\U0001d53b', '\U0001d53e'), ('\U0001d540', '\U0001d544'), ('\U0001d546',
+ '\U0001d546'), ('\U0001d54a', '\U0001d550'), ('\U0001d552', '\U0001d6a5'), ('\U0001d6a8',
+ '\U0001d6c0'), ('\U0001d6c1', '\U0001d6c1'), ('\U0001d6c2', '\U0001d6da'), ('\U0001d6db',
+ '\U0001d6db'), ('\U0001d6dc', '\U0001d6fa'), ('\U0001d6fb', '\U0001d6fb'), ('\U0001d6fc',
+ '\U0001d714'), ('\U0001d715', '\U0001d715'), ('\U0001d716', '\U0001d734'), ('\U0001d735',
+ '\U0001d735'), ('\U0001d736', '\U0001d74e'), ('\U0001d74f', '\U0001d74f'), ('\U0001d750',
+ '\U0001d76e'), ('\U0001d76f', '\U0001d76f'), ('\U0001d770', '\U0001d788'), ('\U0001d789',
+ '\U0001d789'), ('\U0001d78a', '\U0001d7a8'), ('\U0001d7a9', '\U0001d7a9'), ('\U0001d7aa',
+ '\U0001d7c2'), ('\U0001d7c3', '\U0001d7c3'), ('\U0001d7c4', '\U0001d7cb'), ('\U0001d7ce',
+ '\U0001d7ff'), ('\U0001f000', '\U0001f02b'), ('\U0001f030', '\U0001f093'), ('\U0001f0a0',
+ '\U0001f0ae'), ('\U0001f0b1', '\U0001f0bf'), ('\U0001f0c1', '\U0001f0cf'), ('\U0001f0d1',
+ '\U0001f0f5'), ('\U0001f100', '\U0001f10c'), ('\U0001f110', '\U0001f12e'), ('\U0001f130',
+ '\U0001f16b'), ('\U0001f170', '\U0001f19a'), ('\U0001f1e6', '\U0001f1ff'), ('\U0001f201',
+ '\U0001f202'), ('\U0001f210', '\U0001f23a'), ('\U0001f240', '\U0001f248'), ('\U0001f250',
+ '\U0001f251'), ('\U0001f300', '\U0001f32c'), ('\U0001f330', '\U0001f37d'), ('\U0001f380',
+ '\U0001f3ce'), ('\U0001f3d4', '\U0001f3f7'), ('\U0001f400', '\U0001f4fe'), ('\U0001f500',
+ '\U0001f54a'), ('\U0001f550', '\U0001f579'), ('\U0001f57b', '\U0001f5a3'), ('\U0001f5a5',
+ '\U0001f642'), ('\U0001f645', '\U0001f6cf'), ('\U0001f6e0', '\U0001f6ec'), ('\U0001f6f0',
+ '\U0001f6f3'), ('\U0001f700', '\U0001f773'), ('\U0001f780', '\U0001f7d4'), ('\U0001f800',
+ '\U0001f80b'), ('\U0001f810', '\U0001f847'), ('\U0001f850', '\U0001f859'), ('\U0001f860',
+ '\U0001f887'), ('\U0001f890', '\U0001f8ad'), ('\U000e0001', '\U000e0001'), ('\U000e0020',
+ '\U000e007f')
+ ];
+
+ pub static Coptic_table: &'static [(char, char)] = &[
+ ('\u03e2', '\u03ef'), ('\u2c80', '\u2ce4'), ('\u2ce5', '\u2cea'), ('\u2ceb', '\u2cee'),
+ ('\u2cef', '\u2cf1'), ('\u2cf2', '\u2cf3'), ('\u2cf9', '\u2cfc'), ('\u2cfd', '\u2cfd'),
+ ('\u2cfe', '\u2cff')
+ ];
+
+ pub static Cuneiform_table: &'static [(char, char)] = &[
+ ('\U00012000', '\U00012398'), ('\U00012400', '\U0001246e'), ('\U00012470', '\U00012474')
+ ];
+
+ pub static Cypriot_table: &'static [(char, char)] = &[
+ ('\U00010800', '\U00010805'), ('\U00010808', '\U00010808'), ('\U0001080a', '\U00010835'),
+ ('\U00010837', '\U00010838'), ('\U0001083c', '\U0001083c'), ('\U0001083f', '\U0001083f')
+ ];
+
+ pub static Cyrillic_table: &'static [(char, char)] = &[
+ ('\u0400', '\u0481'), ('\u0482', '\u0482'), ('\u0483', '\u0484'), ('\u0487', '\u0487'),
+ ('\u0488', '\u0489'), ('\u048a', '\u052f'), ('\u1d2b', '\u1d2b'), ('\u1d78', '\u1d78'),
+ ('\u2de0', '\u2dff'), ('\ua640', '\ua66d'), ('\ua66e', '\ua66e'), ('\ua66f', '\ua66f'),
+ ('\ua670', '\ua672'), ('\ua673', '\ua673'), ('\ua674', '\ua67d'), ('\ua67e', '\ua67e'),
+ ('\ua67f', '\ua67f'), ('\ua680', '\ua69b'), ('\ua69c', '\ua69d'), ('\ua69f', '\ua69f')
+ ];
+
+ pub static Deseret_table: &'static [(char, char)] = &[
+ ('\U00010400', '\U0001044f')
+ ];
+
+ pub static Devanagari_table: &'static [(char, char)] = &[
+ ('\u0900', '\u0902'), ('\u0903', '\u0903'), ('\u0904', '\u0939'), ('\u093a', '\u093a'),
+ ('\u093b', '\u093b'), ('\u093c', '\u093c'), ('\u093d', '\u093d'), ('\u093e', '\u0940'),
+ ('\u0941', '\u0948'), ('\u0949', '\u094c'), ('\u094d', '\u094d'), ('\u094e', '\u094f'),
+ ('\u0950', '\u0950'), ('\u0953', '\u0957'), ('\u0958', '\u0961'), ('\u0962', '\u0963'),
+ ('\u0966', '\u096f'), ('\u0970', '\u0970'), ('\u0971', '\u0971'), ('\u0972', '\u097f'),
+ ('\ua8e0', '\ua8f1'), ('\ua8f2', '\ua8f7'), ('\ua8f8', '\ua8fa'), ('\ua8fb', '\ua8fb')
+ ];
+
+ pub static Duployan_table: &'static [(char, char)] = &[
+ ('\U0001bc00', '\U0001bc6a'), ('\U0001bc70', '\U0001bc7c'), ('\U0001bc80', '\U0001bc88'),
+ ('\U0001bc90', '\U0001bc99'), ('\U0001bc9c', '\U0001bc9c'), ('\U0001bc9d', '\U0001bc9e'),
+ ('\U0001bc9f', '\U0001bc9f')
+ ];
+
+ pub static Egyptian_Hieroglyphs_table: &'static [(char, char)] = &[
+ ('\U00013000', '\U0001342e')
+ ];
+
+ pub static Elbasan_table: &'static [(char, char)] = &[
+ ('\U00010500', '\U00010527')
+ ];
+
+ pub static Ethiopic_table: &'static [(char, char)] = &[
+ ('\u1200', '\u1248'), ('\u124a', '\u124d'), ('\u1250', '\u1256'), ('\u1258', '\u1258'),
+ ('\u125a', '\u125d'), ('\u1260', '\u1288'), ('\u128a', '\u128d'), ('\u1290', '\u12b0'),
+ ('\u12b2', '\u12b5'), ('\u12b8', '\u12be'), ('\u12c0', '\u12c0'), ('\u12c2', '\u12c5'),
+ ('\u12c8', '\u12d6'), ('\u12d8', '\u1310'), ('\u1312', '\u1315'), ('\u1318', '\u135a'),
+ ('\u135d', '\u135f'), ('\u1360', '\u1368'), ('\u1369', '\u137c'), ('\u1380', '\u138f'),
+ ('\u1390', '\u1399'), ('\u2d80', '\u2d96'), ('\u2da0', '\u2da6'), ('\u2da8', '\u2dae'),
+ ('\u2db0', '\u2db6'), ('\u2db8', '\u2dbe'), ('\u2dc0', '\u2dc6'), ('\u2dc8', '\u2dce'),
+ ('\u2dd0', '\u2dd6'), ('\u2dd8', '\u2dde'), ('\uab01', '\uab06'), ('\uab09', '\uab0e'),
+ ('\uab11', '\uab16'), ('\uab20', '\uab26'), ('\uab28', '\uab2e')
+ ];
+
+ pub static Georgian_table: &'static [(char, char)] = &[
+ ('\u10a0', '\u10c5'), ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'), ('\u10d0', '\u10fa'),
+ ('\u10fc', '\u10fc'), ('\u10fd', '\u10ff'), ('\u2d00', '\u2d25'), ('\u2d27', '\u2d27'),
+ ('\u2d2d', '\u2d2d')
+ ];
+
+ pub static Glagolitic_table: &'static [(char, char)] = &[
+ ('\u2c00', '\u2c2e'), ('\u2c30', '\u2c5e')
+ ];
+
+ pub static Gothic_table: &'static [(char, char)] = &[
+ ('\U00010330', '\U00010340'), ('\U00010341', '\U00010341'), ('\U00010342', '\U00010349'),
+ ('\U0001034a', '\U0001034a')
+ ];
+
+ pub static Grantha_table: &'static [(char, char)] = &[
+ ('\U00011301', '\U00011301'), ('\U00011302', '\U00011303'), ('\U00011305', '\U0001130c'),
+ ('\U0001130f', '\U00011310'), ('\U00011313', '\U00011328'), ('\U0001132a', '\U00011330'),
+ ('\U00011332', '\U00011333'), ('\U00011335', '\U00011339'), ('\U0001133c', '\U0001133c'),
+ ('\U0001133d', '\U0001133d'), ('\U0001133e', '\U0001133f'), ('\U00011340', '\U00011340'),
+ ('\U00011341', '\U00011344'), ('\U00011347', '\U00011348'), ('\U0001134b', '\U0001134d'),
+ ('\U00011357', '\U00011357'), ('\U0001135d', '\U00011361'), ('\U00011362', '\U00011363'),
+ ('\U00011366', '\U0001136c'), ('\U00011370', '\U00011374')
+ ];
+
+ pub static Greek_table: &'static [(char, char)] = &[
+ ('\u0370', '\u0373'), ('\u0375', '\u0375'), ('\u0376', '\u0377'), ('\u037a', '\u037a'),
+ ('\u037b', '\u037d'), ('\u037f', '\u037f'), ('\u0384', '\u0384'), ('\u0386', '\u0386'),
+ ('\u0388', '\u038a'), ('\u038c', '\u038c'), ('\u038e', '\u03a1'), ('\u03a3', '\u03e1'),
+ ('\u03f0', '\u03f5'), ('\u03f6', '\u03f6'), ('\u03f7', '\u03ff'), ('\u1d26', '\u1d2a'),
+ ('\u1d5d', '\u1d61'), ('\u1d66', '\u1d6a'), ('\u1dbf', '\u1dbf'), ('\u1f00', '\u1f15'),
+ ('\u1f18', '\u1f1d'), ('\u1f20', '\u1f45'), ('\u1f48', '\u1f4d'), ('\u1f50', '\u1f57'),
+ ('\u1f59', '\u1f59'), ('\u1f5b', '\u1f5b'), ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f7d'),
+ ('\u1f80', '\u1fb4'), ('\u1fb6', '\u1fbc'), ('\u1fbd', '\u1fbd'), ('\u1fbe', '\u1fbe'),
+ ('\u1fbf', '\u1fc1'), ('\u1fc2', '\u1fc4'), ('\u1fc6', '\u1fcc'), ('\u1fcd', '\u1fcf'),
+ ('\u1fd0', '\u1fd3'), ('\u1fd6', '\u1fdb'), ('\u1fdd', '\u1fdf'), ('\u1fe0', '\u1fec'),
+ ('\u1fed', '\u1fef'), ('\u1ff2', '\u1ff4'), ('\u1ff6', '\u1ffc'), ('\u1ffd', '\u1ffe'),
+ ('\u2126', '\u2126'), ('\uab65', '\uab65'), ('\U00010140', '\U00010174'), ('\U00010175',
+ '\U00010178'), ('\U00010179', '\U00010189'), ('\U0001018a', '\U0001018b'), ('\U0001018c',
+ '\U0001018c'), ('\U000101a0', '\U000101a0'), ('\U0001d200', '\U0001d241'), ('\U0001d242',
+ '\U0001d244'), ('\U0001d245', '\U0001d245')
+ ];
+
+ pub static Gujarati_table: &'static [(char, char)] = &[
+ ('\u0a81', '\u0a82'), ('\u0a83', '\u0a83'), ('\u0a85', '\u0a8d'), ('\u0a8f', '\u0a91'),
+ ('\u0a93', '\u0aa8'), ('\u0aaa', '\u0ab0'), ('\u0ab2', '\u0ab3'), ('\u0ab5', '\u0ab9'),
+ ('\u0abc', '\u0abc'), ('\u0abd', '\u0abd'), ('\u0abe', '\u0ac0'), ('\u0ac1', '\u0ac5'),
+ ('\u0ac7', '\u0ac8'), ('\u0ac9', '\u0ac9'), ('\u0acb', '\u0acc'), ('\u0acd', '\u0acd'),
+ ('\u0ad0', '\u0ad0'), ('\u0ae0', '\u0ae1'), ('\u0ae2', '\u0ae3'), ('\u0ae6', '\u0aef'),
+ ('\u0af0', '\u0af0'), ('\u0af1', '\u0af1')
+ ];
+
+ pub static Gurmukhi_table: &'static [(char, char)] = &[
+ ('\u0a01', '\u0a02'), ('\u0a03', '\u0a03'), ('\u0a05', '\u0a0a'), ('\u0a0f', '\u0a10'),
+ ('\u0a13', '\u0a28'), ('\u0a2a', '\u0a30'), ('\u0a32', '\u0a33'), ('\u0a35', '\u0a36'),
+ ('\u0a38', '\u0a39'), ('\u0a3c', '\u0a3c'), ('\u0a3e', '\u0a40'), ('\u0a41', '\u0a42'),
+ ('\u0a47', '\u0a48'), ('\u0a4b', '\u0a4d'), ('\u0a51', '\u0a51'), ('\u0a59', '\u0a5c'),
+ ('\u0a5e', '\u0a5e'), ('\u0a66', '\u0a6f'), ('\u0a70', '\u0a71'), ('\u0a72', '\u0a74'),
+ ('\u0a75', '\u0a75')
+ ];
+
+ pub static Han_table: &'static [(char, char)] = &[
+ ('\u2e80', '\u2e99'), ('\u2e9b', '\u2ef3'), ('\u2f00', '\u2fd5'), ('\u3005', '\u3005'),
+ ('\u3007', '\u3007'), ('\u3021', '\u3029'), ('\u3038', '\u303a'), ('\u303b', '\u303b'),
+ ('\u3400', '\u4db5'), ('\u4e00', '\u9fcc'), ('\uf900', '\ufa6d'), ('\ufa70', '\ufad9'),
+ ('\U00020000', '\U0002a6d6'), ('\U0002a700', '\U0002b734'), ('\U0002b740', '\U0002b81d'),
+ ('\U0002f800', '\U0002fa1d')
+ ];
+
+ pub static Hangul_table: &'static [(char, char)] = &[
+ ('\u1100', '\u11ff'), ('\u302e', '\u302f'), ('\u3131', '\u318e'), ('\u3200', '\u321e'),
+ ('\u3260', '\u327e'), ('\ua960', '\ua97c'), ('\uac00', '\ud7a3'), ('\ud7b0', '\ud7c6'),
+ ('\ud7cb', '\ud7fb'), ('\uffa0', '\uffbe'), ('\uffc2', '\uffc7'), ('\uffca', '\uffcf'),
+ ('\uffd2', '\uffd7'), ('\uffda', '\uffdc')
+ ];
+
+ pub static Hanunoo_table: &'static [(char, char)] = &[
+ ('\u1720', '\u1731'), ('\u1732', '\u1734')
+ ];
+
+ pub static Hebrew_table: &'static [(char, char)] = &[
+ ('\u0591', '\u05bd'), ('\u05be', '\u05be'), ('\u05bf', '\u05bf'), ('\u05c0', '\u05c0'),
+ ('\u05c1', '\u05c2'), ('\u05c3', '\u05c3'), ('\u05c4', '\u05c5'), ('\u05c6', '\u05c6'),
+ ('\u05c7', '\u05c7'), ('\u05d0', '\u05ea'), ('\u05f0', '\u05f2'), ('\u05f3', '\u05f4'),
+ ('\ufb1d', '\ufb1d'), ('\ufb1e', '\ufb1e'), ('\ufb1f', '\ufb28'), ('\ufb29', '\ufb29'),
+ ('\ufb2a', '\ufb36'), ('\ufb38', '\ufb3c'), ('\ufb3e', '\ufb3e'), ('\ufb40', '\ufb41'),
+ ('\ufb43', '\ufb44'), ('\ufb46', '\ufb4f')
+ ];
+
+ pub static Hiragana_table: &'static [(char, char)] = &[
+ ('\u3041', '\u3096'), ('\u309d', '\u309e'), ('\u309f', '\u309f'), ('\U0001b001',
+ '\U0001b001'), ('\U0001f200', '\U0001f200')
+ ];
+
+ pub static Imperial_Aramaic_table: &'static [(char, char)] = &[
+ ('\U00010840', '\U00010855'), ('\U00010857', '\U00010857'), ('\U00010858', '\U0001085f')
+ ];
+
+ pub static Inherited_table: &'static [(char, char)] = &[
+ ('\u0300', '\u036f'), ('\u0485', '\u0486'), ('\u064b', '\u0655'), ('\u0670', '\u0670'),
+ ('\u0951', '\u0952'), ('\u1ab0', '\u1abd'), ('\u1abe', '\u1abe'), ('\u1cd0', '\u1cd2'),
+ ('\u1cd4', '\u1ce0'), ('\u1ce2', '\u1ce8'), ('\u1ced', '\u1ced'), ('\u1cf4', '\u1cf4'),
+ ('\u1cf8', '\u1cf9'), ('\u1dc0', '\u1df5'), ('\u1dfc', '\u1dff'), ('\u200c', '\u200d'),
+ ('\u20d0', '\u20dc'), ('\u20dd', '\u20e0'), ('\u20e1', '\u20e1'), ('\u20e2', '\u20e4'),
+ ('\u20e5', '\u20f0'), ('\u302a', '\u302d'), ('\u3099', '\u309a'), ('\ufe00', '\ufe0f'),
+ ('\ufe20', '\ufe2d'), ('\U000101fd', '\U000101fd'), ('\U000102e0', '\U000102e0'),
+ ('\U0001d167', '\U0001d169'), ('\U0001d17b', '\U0001d182'), ('\U0001d185', '\U0001d18b'),
+ ('\U0001d1aa', '\U0001d1ad'), ('\U000e0100', '\U000e01ef')
+ ];
+
+ pub static Inscriptional_Pahlavi_table: &'static [(char, char)] = &[
+ ('\U00010b60', '\U00010b72'), ('\U00010b78', '\U00010b7f')
+ ];
+
+ pub static Inscriptional_Parthian_table: &'static [(char, char)] = &[
+ ('\U00010b40', '\U00010b55'), ('\U00010b58', '\U00010b5f')
+ ];
+
+ pub static Javanese_table: &'static [(char, char)] = &[
+ ('\ua980', '\ua982'), ('\ua983', '\ua983'), ('\ua984', '\ua9b2'), ('\ua9b3', '\ua9b3'),
+ ('\ua9b4', '\ua9b5'), ('\ua9b6', '\ua9b9'), ('\ua9ba', '\ua9bb'), ('\ua9bc', '\ua9bc'),
+ ('\ua9bd', '\ua9c0'), ('\ua9c1', '\ua9cd'), ('\ua9d0', '\ua9d9'), ('\ua9de', '\ua9df')
+ ];
+
+ pub static Kaithi_table: &'static [(char, char)] = &[
+ ('\U00011080', '\U00011081'), ('\U00011082', '\U00011082'), ('\U00011083', '\U000110af'),
+ ('\U000110b0', '\U000110b2'), ('\U000110b3', '\U000110b6'), ('\U000110b7', '\U000110b8'),
+ ('\U000110b9', '\U000110ba'), ('\U000110bb', '\U000110bc'), ('\U000110bd', '\U000110bd'),
+ ('\U000110be', '\U000110c1')
+ ];
+
+ pub static Kannada_table: &'static [(char, char)] = &[
+ ('\u0c81', '\u0c81'), ('\u0c82', '\u0c83'), ('\u0c85', '\u0c8c'), ('\u0c8e', '\u0c90'),
+ ('\u0c92', '\u0ca8'), ('\u0caa', '\u0cb3'), ('\u0cb5', '\u0cb9'), ('\u0cbc', '\u0cbc'),
+ ('\u0cbd', '\u0cbd'), ('\u0cbe', '\u0cbe'), ('\u0cbf', '\u0cbf'), ('\u0cc0', '\u0cc4'),
+ ('\u0cc6', '\u0cc6'), ('\u0cc7', '\u0cc8'), ('\u0cca', '\u0ccb'), ('\u0ccc', '\u0ccd'),
+ ('\u0cd5', '\u0cd6'), ('\u0cde', '\u0cde'), ('\u0ce0', '\u0ce1'), ('\u0ce2', '\u0ce3'),
+ ('\u0ce6', '\u0cef'), ('\u0cf1', '\u0cf2')
+ ];
+
+ pub static Katakana_table: &'static [(char, char)] = &[
+ ('\u30a1', '\u30fa'), ('\u30fd', '\u30fe'), ('\u30ff', '\u30ff'), ('\u31f0', '\u31ff'),
+ ('\u32d0', '\u32fe'), ('\u3300', '\u3357'), ('\uff66', '\uff6f'), ('\uff71', '\uff9d'),
+ ('\U0001b000', '\U0001b000')
+ ];
+
+ pub static Kayah_Li_table: &'static [(char, char)] = &[
+ ('\ua900', '\ua909'), ('\ua90a', '\ua925'), ('\ua926', '\ua92d'), ('\ua92f', '\ua92f')
+ ];
+
+ pub static Kharoshthi_table: &'static [(char, char)] = &[
+ ('\U00010a00', '\U00010a00'), ('\U00010a01', '\U00010a03'), ('\U00010a05', '\U00010a06'),
+ ('\U00010a0c', '\U00010a0f'), ('\U00010a10', '\U00010a13'), ('\U00010a15', '\U00010a17'),
+ ('\U00010a19', '\U00010a33'), ('\U00010a38', '\U00010a3a'), ('\U00010a3f', '\U00010a3f'),
+ ('\U00010a40', '\U00010a47'), ('\U00010a50', '\U00010a58')
+ ];
+
+ pub static Khmer_table: &'static [(char, char)] = &[
+ ('\u1780', '\u17b3'), ('\u17b4', '\u17b5'), ('\u17b6', '\u17b6'), ('\u17b7', '\u17bd'),
+ ('\u17be', '\u17c5'), ('\u17c6', '\u17c6'), ('\u17c7', '\u17c8'), ('\u17c9', '\u17d3'),
+ ('\u17d4', '\u17d6'), ('\u17d7', '\u17d7'), ('\u17d8', '\u17da'), ('\u17db', '\u17db'),
+ ('\u17dc', '\u17dc'), ('\u17dd', '\u17dd'), ('\u17e0', '\u17e9'), ('\u17f0', '\u17f9'),
+ ('\u19e0', '\u19ff')
+ ];
+
+ pub static Khojki_table: &'static [(char, char)] = &[
+ ('\U00011200', '\U00011211'), ('\U00011213', '\U0001122b'), ('\U0001122c', '\U0001122e'),
+ ('\U0001122f', '\U00011231'), ('\U00011232', '\U00011233'), ('\U00011234', '\U00011234'),
+ ('\U00011235', '\U00011235'), ('\U00011236', '\U00011237'), ('\U00011238', '\U0001123d')
+ ];
+
+ pub static Khudawadi_table: &'static [(char, char)] = &[
+ ('\U000112b0', '\U000112de'), ('\U000112df', '\U000112df'), ('\U000112e0', '\U000112e2'),
+ ('\U000112e3', '\U000112ea'), ('\U000112f0', '\U000112f9')
+ ];
+
+ pub static Lao_table: &'static [(char, char)] = &[
+ ('\u0e81', '\u0e82'), ('\u0e84', '\u0e84'), ('\u0e87', '\u0e88'), ('\u0e8a', '\u0e8a'),
+ ('\u0e8d', '\u0e8d'), ('\u0e94', '\u0e97'), ('\u0e99', '\u0e9f'), ('\u0ea1', '\u0ea3'),
+ ('\u0ea5', '\u0ea5'), ('\u0ea7', '\u0ea7'), ('\u0eaa', '\u0eab'), ('\u0ead', '\u0eb0'),
+ ('\u0eb1', '\u0eb1'), ('\u0eb2', '\u0eb3'), ('\u0eb4', '\u0eb9'), ('\u0ebb', '\u0ebc'),
+ ('\u0ebd', '\u0ebd'), ('\u0ec0', '\u0ec4'), ('\u0ec6', '\u0ec6'), ('\u0ec8', '\u0ecd'),
+ ('\u0ed0', '\u0ed9'), ('\u0edc', '\u0edf')
+ ];
+
+ pub static Latin_table: &'static [(char, char)] = &[
+ ('\x41', '\x5a'), ('\x61', '\x7a'), ('\xaa', '\xaa'), ('\xba', '\xba'), ('\xc0', '\xd6'),
+ ('\xd8', '\xf6'), ('\xf8', '\u01ba'), ('\u01bb', '\u01bb'), ('\u01bc', '\u01bf'), ('\u01c0',
+ '\u01c3'), ('\u01c4', '\u0293'), ('\u0294', '\u0294'), ('\u0295', '\u02af'), ('\u02b0',
+ '\u02b8'), ('\u02e0', '\u02e4'), ('\u1d00', '\u1d25'), ('\u1d2c', '\u1d5c'), ('\u1d62',
+ '\u1d65'), ('\u1d6b', '\u1d77'), ('\u1d79', '\u1d9a'), ('\u1d9b', '\u1dbe'), ('\u1e00',
+ '\u1eff'), ('\u2071', '\u2071'), ('\u207f', '\u207f'), ('\u2090', '\u209c'), ('\u212a',
+ '\u212b'), ('\u2132', '\u2132'), ('\u214e', '\u214e'), ('\u2160', '\u2182'), ('\u2183',
+ '\u2184'), ('\u2185', '\u2188'), ('\u2c60', '\u2c7b'), ('\u2c7c', '\u2c7d'), ('\u2c7e',
+ '\u2c7f'), ('\ua722', '\ua76f'), ('\ua770', '\ua770'), ('\ua771', '\ua787'), ('\ua78b',
+ '\ua78e'), ('\ua790', '\ua7ad'), ('\ua7b0', '\ua7b1'), ('\ua7f7', '\ua7f7'), ('\ua7f8',
+ '\ua7f9'), ('\ua7fa', '\ua7fa'), ('\ua7fb', '\ua7ff'), ('\uab30', '\uab5a'), ('\uab5c',
+ '\uab5f'), ('\uab64', '\uab64'), ('\ufb00', '\ufb06'), ('\uff21', '\uff3a'), ('\uff41',
+ '\uff5a')
+ ];
+
+ pub static Lepcha_table: &'static [(char, char)] = &[
+ ('\u1c00', '\u1c23'), ('\u1c24', '\u1c2b'), ('\u1c2c', '\u1c33'), ('\u1c34', '\u1c35'),
+ ('\u1c36', '\u1c37'), ('\u1c3b', '\u1c3f'), ('\u1c40', '\u1c49'), ('\u1c4d', '\u1c4f')
+ ];
+
+ pub static Limbu_table: &'static [(char, char)] = &[
+ ('\u1900', '\u191e'), ('\u1920', '\u1922'), ('\u1923', '\u1926'), ('\u1927', '\u1928'),
+ ('\u1929', '\u192b'), ('\u1930', '\u1931'), ('\u1932', '\u1932'), ('\u1933', '\u1938'),
+ ('\u1939', '\u193b'), ('\u1940', '\u1940'), ('\u1944', '\u1945'), ('\u1946', '\u194f')
+ ];
+
+ pub static Linear_A_table: &'static [(char, char)] = &[
+ ('\U00010600', '\U00010736'), ('\U00010740', '\U00010755'), ('\U00010760', '\U00010767')
+ ];
+
+ pub static Linear_B_table: &'static [(char, char)] = &[
+ ('\U00010000', '\U0001000b'), ('\U0001000d', '\U00010026'), ('\U00010028', '\U0001003a'),
+ ('\U0001003c', '\U0001003d'), ('\U0001003f', '\U0001004d'), ('\U00010050', '\U0001005d'),
+ ('\U00010080', '\U000100fa')
+ ];
+
+ pub static Lisu_table: &'static [(char, char)] = &[
+ ('\ua4d0', '\ua4f7'), ('\ua4f8', '\ua4fd'), ('\ua4fe', '\ua4ff')
+ ];
+
+ pub static Lycian_table: &'static [(char, char)] = &[
+ ('\U00010280', '\U0001029c')
+ ];
+
+ pub static Lydian_table: &'static [(char, char)] = &[
+ ('\U00010920', '\U00010939'), ('\U0001093f', '\U0001093f')
+ ];
+
+ pub static Mahajani_table: &'static [(char, char)] = &[
+ ('\U00011150', '\U00011172'), ('\U00011173', '\U00011173'), ('\U00011174', '\U00011175'),
+ ('\U00011176', '\U00011176')
+ ];
+
+ pub static Malayalam_table: &'static [(char, char)] = &[
+ ('\u0d01', '\u0d01'), ('\u0d02', '\u0d03'), ('\u0d05', '\u0d0c'), ('\u0d0e', '\u0d10'),
+ ('\u0d12', '\u0d3a'), ('\u0d3d', '\u0d3d'), ('\u0d3e', '\u0d40'), ('\u0d41', '\u0d44'),
+ ('\u0d46', '\u0d48'), ('\u0d4a', '\u0d4c'), ('\u0d4d', '\u0d4d'), ('\u0d4e', '\u0d4e'),
+ ('\u0d57', '\u0d57'), ('\u0d60', '\u0d61'), ('\u0d62', '\u0d63'), ('\u0d66', '\u0d6f'),
+ ('\u0d70', '\u0d75'), ('\u0d79', '\u0d79'), ('\u0d7a', '\u0d7f')
+ ];
+
+ pub static Mandaic_table: &'static [(char, char)] = &[
+ ('\u0840', '\u0858'), ('\u0859', '\u085b'), ('\u085e', '\u085e')
+ ];
+
+ pub static Manichaean_table: &'static [(char, char)] = &[
+ ('\U00010ac0', '\U00010ac7'), ('\U00010ac8', '\U00010ac8'), ('\U00010ac9', '\U00010ae4'),
+ ('\U00010ae5', '\U00010ae6'), ('\U00010aeb', '\U00010aef'), ('\U00010af0', '\U00010af6')
+ ];
+
+ pub static Meetei_Mayek_table: &'static [(char, char)] = &[
+ ('\uaae0', '\uaaea'), ('\uaaeb', '\uaaeb'), ('\uaaec', '\uaaed'), ('\uaaee', '\uaaef'),
+ ('\uaaf0', '\uaaf1'), ('\uaaf2', '\uaaf2'), ('\uaaf3', '\uaaf4'), ('\uaaf5', '\uaaf5'),
+ ('\uaaf6', '\uaaf6'), ('\uabc0', '\uabe2'), ('\uabe3', '\uabe4'), ('\uabe5', '\uabe5'),
+ ('\uabe6', '\uabe7'), ('\uabe8', '\uabe8'), ('\uabe9', '\uabea'), ('\uabeb', '\uabeb'),
+ ('\uabec', '\uabec'), ('\uabed', '\uabed'), ('\uabf0', '\uabf9')
+ ];
+
+ pub static Mende_Kikakui_table: &'static [(char, char)] = &[
+ ('\U0001e800', '\U0001e8c4'), ('\U0001e8c7', '\U0001e8cf'), ('\U0001e8d0', '\U0001e8d6')
+ ];
+
+ pub static Meroitic_Cursive_table: &'static [(char, char)] = &[
+ ('\U000109a0', '\U000109b7'), ('\U000109be', '\U000109bf')
+ ];
+
+ pub static Meroitic_Hieroglyphs_table: &'static [(char, char)] = &[
+ ('\U00010980', '\U0001099f')
+ ];
+
+ pub static Miao_table: &'static [(char, char)] = &[
+ ('\U00016f00', '\U00016f44'), ('\U00016f50', '\U00016f50'), ('\U00016f51', '\U00016f7e'),
+ ('\U00016f8f', '\U00016f92'), ('\U00016f93', '\U00016f9f')
+ ];
+
+ pub static Modi_table: &'static [(char, char)] = &[
+ ('\U00011600', '\U0001162f'), ('\U00011630', '\U00011632'), ('\U00011633', '\U0001163a'),
+ ('\U0001163b', '\U0001163c'), ('\U0001163d', '\U0001163d'), ('\U0001163e', '\U0001163e'),
+ ('\U0001163f', '\U00011640'), ('\U00011641', '\U00011643'), ('\U00011644', '\U00011644'),
+ ('\U00011650', '\U00011659')
+ ];
+
+ pub static Mongolian_table: &'static [(char, char)] = &[
+ ('\u1800', '\u1801'), ('\u1804', '\u1804'), ('\u1806', '\u1806'), ('\u1807', '\u180a'),
+ ('\u180b', '\u180d'), ('\u180e', '\u180e'), ('\u1810', '\u1819'), ('\u1820', '\u1842'),
+ ('\u1843', '\u1843'), ('\u1844', '\u1877'), ('\u1880', '\u18a8'), ('\u18a9', '\u18a9'),
+ ('\u18aa', '\u18aa')
+ ];
+
+ pub static Mro_table: &'static [(char, char)] = &[
+ ('\U00016a40', '\U00016a5e'), ('\U00016a60', '\U00016a69'), ('\U00016a6e', '\U00016a6f')
+ ];
+
+ pub static Myanmar_table: &'static [(char, char)] = &[
+ ('\u1000', '\u102a'), ('\u102b', '\u102c'), ('\u102d', '\u1030'), ('\u1031', '\u1031'),
+ ('\u1032', '\u1037'), ('\u1038', '\u1038'), ('\u1039', '\u103a'), ('\u103b', '\u103c'),
+ ('\u103d', '\u103e'), ('\u103f', '\u103f'), ('\u1040', '\u1049'), ('\u104a', '\u104f'),
+ ('\u1050', '\u1055'), ('\u1056', '\u1057'), ('\u1058', '\u1059'), ('\u105a', '\u105d'),
+ ('\u105e', '\u1060'), ('\u1061', '\u1061'), ('\u1062', '\u1064'), ('\u1065', '\u1066'),
+ ('\u1067', '\u106d'), ('\u106e', '\u1070'), ('\u1071', '\u1074'), ('\u1075', '\u1081'),
+ ('\u1082', '\u1082'), ('\u1083', '\u1084'), ('\u1085', '\u1086'), ('\u1087', '\u108c'),
+ ('\u108d', '\u108d'), ('\u108e', '\u108e'), ('\u108f', '\u108f'), ('\u1090', '\u1099'),
+ ('\u109a', '\u109c'), ('\u109d', '\u109d'), ('\u109e', '\u109f'), ('\ua9e0', '\ua9e4'),
+ ('\ua9e5', '\ua9e5'), ('\ua9e6', '\ua9e6'), ('\ua9e7', '\ua9ef'), ('\ua9f0', '\ua9f9'),
+ ('\ua9fa', '\ua9fe'), ('\uaa60', '\uaa6f'), ('\uaa70', '\uaa70'), ('\uaa71', '\uaa76'),
+ ('\uaa77', '\uaa79'), ('\uaa7a', '\uaa7a'), ('\uaa7b', '\uaa7b'), ('\uaa7c', '\uaa7c'),
+ ('\uaa7d', '\uaa7d'), ('\uaa7e', '\uaa7f')
+ ];
+
+ pub static Nabataean_table: &'static [(char, char)] = &[
+ ('\U00010880', '\U0001089e'), ('\U000108a7', '\U000108af')
+ ];
+
+ pub static New_Tai_Lue_table: &'static [(char, char)] = &[
+ ('\u1980', '\u19ab'), ('\u19b0', '\u19c0'), ('\u19c1', '\u19c7'), ('\u19c8', '\u19c9'),
+ ('\u19d0', '\u19d9'), ('\u19da', '\u19da'), ('\u19de', '\u19df')
+ ];
+
+ pub static Nko_table: &'static [(char, char)] = &[
+ ('\u07c0', '\u07c9'), ('\u07ca', '\u07ea'), ('\u07eb', '\u07f3'), ('\u07f4', '\u07f5'),
+ ('\u07f6', '\u07f6'), ('\u07f7', '\u07f9'), ('\u07fa', '\u07fa')
+ ];
+
+ pub static Ogham_table: &'static [(char, char)] = &[
+ ('\u1680', '\u1680'), ('\u1681', '\u169a'), ('\u169b', '\u169b'), ('\u169c', '\u169c')
+ ];
+
+ pub static Ol_Chiki_table: &'static [(char, char)] = &[
+ ('\u1c50', '\u1c59'), ('\u1c5a', '\u1c77'), ('\u1c78', '\u1c7d'), ('\u1c7e', '\u1c7f')
+ ];
+
+ pub static Old_Italic_table: &'static [(char, char)] = &[
+ ('\U00010300', '\U0001031f'), ('\U00010320', '\U00010323')
+ ];
+
+ pub static Old_North_Arabian_table: &'static [(char, char)] = &[
+ ('\U00010a80', '\U00010a9c'), ('\U00010a9d', '\U00010a9f')
+ ];
+
+ pub static Old_Permic_table: &'static [(char, char)] = &[
+ ('\U00010350', '\U00010375'), ('\U00010376', '\U0001037a')
+ ];
+
+ pub static Old_Persian_table: &'static [(char, char)] = &[
+ ('\U000103a0', '\U000103c3'), ('\U000103c8', '\U000103cf'), ('\U000103d0', '\U000103d0'),
+ ('\U000103d1', '\U000103d5')
+ ];
+
+ pub static Old_South_Arabian_table: &'static [(char, char)] = &[
+ ('\U00010a60', '\U00010a7c'), ('\U00010a7d', '\U00010a7e'), ('\U00010a7f', '\U00010a7f')
+ ];
+
+ pub static Old_Turkic_table: &'static [(char, char)] = &[
+ ('\U00010c00', '\U00010c48')
+ ];
+
+ pub static Oriya_table: &'static [(char, char)] = &[
+ ('\u0b01', '\u0b01'), ('\u0b02', '\u0b03'), ('\u0b05', '\u0b0c'), ('\u0b0f', '\u0b10'),
+ ('\u0b13', '\u0b28'), ('\u0b2a', '\u0b30'), ('\u0b32', '\u0b33'), ('\u0b35', '\u0b39'),
+ ('\u0b3c', '\u0b3c'), ('\u0b3d', '\u0b3d'), ('\u0b3e', '\u0b3e'), ('\u0b3f', '\u0b3f'),
+ ('\u0b40', '\u0b40'), ('\u0b41', '\u0b44'), ('\u0b47', '\u0b48'), ('\u0b4b', '\u0b4c'),
+ ('\u0b4d', '\u0b4d'), ('\u0b56', '\u0b56'), ('\u0b57', '\u0b57'), ('\u0b5c', '\u0b5d'),
+ ('\u0b5f', '\u0b61'), ('\u0b62', '\u0b63'), ('\u0b66', '\u0b6f'), ('\u0b70', '\u0b70'),
+ ('\u0b71', '\u0b71'), ('\u0b72', '\u0b77')
+ ];
+
+ pub static Osmanya_table: &'static [(char, char)] = &[
+ ('\U00010480', '\U0001049d'), ('\U000104a0', '\U000104a9')
+ ];
+
+ pub static Pahawh_Hmong_table: &'static [(char, char)] = &[
+ ('\U00016b00', '\U00016b2f'), ('\U00016b30', '\U00016b36'), ('\U00016b37', '\U00016b3b'),
+ ('\U00016b3c', '\U00016b3f'), ('\U00016b40', '\U00016b43'), ('\U00016b44', '\U00016b44'),
+ ('\U00016b45', '\U00016b45'), ('\U00016b50', '\U00016b59'), ('\U00016b5b', '\U00016b61'),
+ ('\U00016b63', '\U00016b77'), ('\U00016b7d', '\U00016b8f')
+ ];
+
+ pub static Palmyrene_table: &'static [(char, char)] = &[
+ ('\U00010860', '\U00010876'), ('\U00010877', '\U00010878'), ('\U00010879', '\U0001087f')
+ ];
+
+ pub static Pau_Cin_Hau_table: &'static [(char, char)] = &[
+ ('\U00011ac0', '\U00011af8')
+ ];
+
+ pub static Phags_Pa_table: &'static [(char, char)] = &[
+ ('\ua840', '\ua873'), ('\ua874', '\ua877')
+ ];
+
+ pub static Phoenician_table: &'static [(char, char)] = &[
+ ('\U00010900', '\U00010915'), ('\U00010916', '\U0001091b'), ('\U0001091f', '\U0001091f')
+ ];
+
+ pub static Psalter_Pahlavi_table: &'static [(char, char)] = &[
+ ('\U00010b80', '\U00010b91'), ('\U00010b99', '\U00010b9c'), ('\U00010ba9', '\U00010baf')
+ ];
+
+ pub static Rejang_table: &'static [(char, char)] = &[
+ ('\ua930', '\ua946'), ('\ua947', '\ua951'), ('\ua952', '\ua953'), ('\ua95f', '\ua95f')
+ ];
+
+ pub static Runic_table: &'static [(char, char)] = &[
+ ('\u16a0', '\u16ea'), ('\u16ee', '\u16f0'), ('\u16f1', '\u16f8')
+ ];
+
+ pub static Samaritan_table: &'static [(char, char)] = &[
+ ('\u0800', '\u0815'), ('\u0816', '\u0819'), ('\u081a', '\u081a'), ('\u081b', '\u0823'),
+ ('\u0824', '\u0824'), ('\u0825', '\u0827'), ('\u0828', '\u0828'), ('\u0829', '\u082d'),
+ ('\u0830', '\u083e')
+ ];
+
+ pub static Saurashtra_table: &'static [(char, char)] = &[
+ ('\ua880', '\ua881'), ('\ua882', '\ua8b3'), ('\ua8b4', '\ua8c3'), ('\ua8c4', '\ua8c4'),
+ ('\ua8ce', '\ua8cf'), ('\ua8d0', '\ua8d9')
+ ];
+
+ pub static Sharada_table: &'static [(char, char)] = &[
+ ('\U00011180', '\U00011181'), ('\U00011182', '\U00011182'), ('\U00011183', '\U000111b2'),
+ ('\U000111b3', '\U000111b5'), ('\U000111b6', '\U000111be'), ('\U000111bf', '\U000111c0'),
+ ('\U000111c1', '\U000111c4'), ('\U000111c5', '\U000111c8'), ('\U000111cd', '\U000111cd'),
+ ('\U000111d0', '\U000111d9'), ('\U000111da', '\U000111da')
+ ];
+
+ pub static Shavian_table: &'static [(char, char)] = &[
+ ('\U00010450', '\U0001047f')
+ ];
+
+ pub static Siddham_table: &'static [(char, char)] = &[
+ ('\U00011580', '\U000115ae'), ('\U000115af', '\U000115b1'), ('\U000115b2', '\U000115b5'),
+ ('\U000115b8', '\U000115bb'), ('\U000115bc', '\U000115bd'), ('\U000115be', '\U000115be'),
+ ('\U000115bf', '\U000115c0'), ('\U000115c1', '\U000115c9')
+ ];
+
+ pub static Sinhala_table: &'static [(char, char)] = &[
+ ('\u0d82', '\u0d83'), ('\u0d85', '\u0d96'), ('\u0d9a', '\u0db1'), ('\u0db3', '\u0dbb'),
+ ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'), ('\u0dca', '\u0dca'), ('\u0dcf', '\u0dd1'),
+ ('\u0dd2', '\u0dd4'), ('\u0dd6', '\u0dd6'), ('\u0dd8', '\u0ddf'), ('\u0de6', '\u0def'),
+ ('\u0df2', '\u0df3'), ('\u0df4', '\u0df4'), ('\U000111e1', '\U000111f4')
+ ];
+
+ pub static Sora_Sompeng_table: &'static [(char, char)] = &[
+ ('\U000110d0', '\U000110e8'), ('\U000110f0', '\U000110f9')
+ ];
+
+ pub static Sundanese_table: &'static [(char, char)] = &[
+ ('\u1b80', '\u1b81'), ('\u1b82', '\u1b82'), ('\u1b83', '\u1ba0'), ('\u1ba1', '\u1ba1'),
+ ('\u1ba2', '\u1ba5'), ('\u1ba6', '\u1ba7'), ('\u1ba8', '\u1ba9'), ('\u1baa', '\u1baa'),
+ ('\u1bab', '\u1bad'), ('\u1bae', '\u1baf'), ('\u1bb0', '\u1bb9'), ('\u1bba', '\u1bbf'),
+ ('\u1cc0', '\u1cc7')
+ ];
+
+ pub static Syloti_Nagri_table: &'static [(char, char)] = &[
+ ('\ua800', '\ua801'), ('\ua802', '\ua802'), ('\ua803', '\ua805'), ('\ua806', '\ua806'),
+ ('\ua807', '\ua80a'), ('\ua80b', '\ua80b'), ('\ua80c', '\ua822'), ('\ua823', '\ua824'),
+ ('\ua825', '\ua826'), ('\ua827', '\ua827'), ('\ua828', '\ua82b')
+ ];
+
+ pub static Syriac_table: &'static [(char, char)] = &[
+ ('\u0700', '\u070d'), ('\u070f', '\u070f'), ('\u0710', '\u0710'), ('\u0711', '\u0711'),
+ ('\u0712', '\u072f'), ('\u0730', '\u074a'), ('\u074d', '\u074f')
+ ];
+
+ pub static Tagalog_table: &'static [(char, char)] = &[
+ ('\u1700', '\u170c'), ('\u170e', '\u1711'), ('\u1712', '\u1714')
+ ];
+
+ pub static Tagbanwa_table: &'static [(char, char)] = &[
+ ('\u1760', '\u176c'), ('\u176e', '\u1770'), ('\u1772', '\u1773')
+ ];
+
+ pub static Tai_Le_table: &'static [(char, char)] = &[
+ ('\u1950', '\u196d'), ('\u1970', '\u1974')
+ ];
+
+ pub static Tai_Tham_table: &'static [(char, char)] = &[
+ ('\u1a20', '\u1a54'), ('\u1a55', '\u1a55'), ('\u1a56', '\u1a56'), ('\u1a57', '\u1a57'),
+ ('\u1a58', '\u1a5e'), ('\u1a60', '\u1a60'), ('\u1a61', '\u1a61'), ('\u1a62', '\u1a62'),
+ ('\u1a63', '\u1a64'), ('\u1a65', '\u1a6c'), ('\u1a6d', '\u1a72'), ('\u1a73', '\u1a7c'),
+ ('\u1a7f', '\u1a7f'), ('\u1a80', '\u1a89'), ('\u1a90', '\u1a99'), ('\u1aa0', '\u1aa6'),
+ ('\u1aa7', '\u1aa7'), ('\u1aa8', '\u1aad')
+ ];
+
+ pub static Tai_Viet_table: &'static [(char, char)] = &[
+ ('\uaa80', '\uaaaf'), ('\uaab0', '\uaab0'), ('\uaab1', '\uaab1'), ('\uaab2', '\uaab4'),
+ ('\uaab5', '\uaab6'), ('\uaab7', '\uaab8'), ('\uaab9', '\uaabd'), ('\uaabe', '\uaabf'),
+ ('\uaac0', '\uaac0'), ('\uaac1', '\uaac1'), ('\uaac2', '\uaac2'), ('\uaadb', '\uaadc'),
+ ('\uaadd', '\uaadd'), ('\uaade', '\uaadf')
+ ];
+
+ pub static Takri_table: &'static [(char, char)] = &[
+ ('\U00011680', '\U000116aa'), ('\U000116ab', '\U000116ab'), ('\U000116ac', '\U000116ac'),
+ ('\U000116ad', '\U000116ad'), ('\U000116ae', '\U000116af'), ('\U000116b0', '\U000116b5'),
+ ('\U000116b6', '\U000116b6'), ('\U000116b7', '\U000116b7'), ('\U000116c0', '\U000116c9')
+ ];
+
+ pub static Tamil_table: &'static [(char, char)] = &[
+ ('\u0b82', '\u0b82'), ('\u0b83', '\u0b83'), ('\u0b85', '\u0b8a'), ('\u0b8e', '\u0b90'),
+ ('\u0b92', '\u0b95'), ('\u0b99', '\u0b9a'), ('\u0b9c', '\u0b9c'), ('\u0b9e', '\u0b9f'),
+ ('\u0ba3', '\u0ba4'), ('\u0ba8', '\u0baa'), ('\u0bae', '\u0bb9'), ('\u0bbe', '\u0bbf'),
+ ('\u0bc0', '\u0bc0'), ('\u0bc1', '\u0bc2'), ('\u0bc6', '\u0bc8'), ('\u0bca', '\u0bcc'),
+ ('\u0bcd', '\u0bcd'), ('\u0bd0', '\u0bd0'), ('\u0bd7', '\u0bd7'), ('\u0be6', '\u0bef'),
+ ('\u0bf0', '\u0bf2'), ('\u0bf3', '\u0bf8'), ('\u0bf9', '\u0bf9'), ('\u0bfa', '\u0bfa')
+ ];
+
+ pub static Telugu_table: &'static [(char, char)] = &[
+ ('\u0c00', '\u0c00'), ('\u0c01', '\u0c03'), ('\u0c05', '\u0c0c'), ('\u0c0e', '\u0c10'),
+ ('\u0c12', '\u0c28'), ('\u0c2a', '\u0c39'), ('\u0c3d', '\u0c3d'), ('\u0c3e', '\u0c40'),
+ ('\u0c41', '\u0c44'), ('\u0c46', '\u0c48'), ('\u0c4a', '\u0c4d'), ('\u0c55', '\u0c56'),
+ ('\u0c58', '\u0c59'), ('\u0c60', '\u0c61'), ('\u0c62', '\u0c63'), ('\u0c66', '\u0c6f'),
+ ('\u0c78', '\u0c7e'), ('\u0c7f', '\u0c7f')
+ ];
+
+ pub static Thaana_table: &'static [(char, char)] = &[
+ ('\u0780', '\u07a5'), ('\u07a6', '\u07b0'), ('\u07b1', '\u07b1')
+ ];
+
+ pub static Thai_table: &'static [(char, char)] = &[
+ ('\u0e01', '\u0e30'), ('\u0e31', '\u0e31'), ('\u0e32', '\u0e33'), ('\u0e34', '\u0e3a'),
+ ('\u0e40', '\u0e45'), ('\u0e46', '\u0e46'), ('\u0e47', '\u0e4e'), ('\u0e4f', '\u0e4f'),
+ ('\u0e50', '\u0e59'), ('\u0e5a', '\u0e5b')
+ ];
+
+ pub static Tibetan_table: &'static [(char, char)] = &[
+ ('\u0f00', '\u0f00'), ('\u0f01', '\u0f03'), ('\u0f04', '\u0f12'), ('\u0f13', '\u0f13'),
+ ('\u0f14', '\u0f14'), ('\u0f15', '\u0f17'), ('\u0f18', '\u0f19'), ('\u0f1a', '\u0f1f'),
+ ('\u0f20', '\u0f29'), ('\u0f2a', '\u0f33'), ('\u0f34', '\u0f34'), ('\u0f35', '\u0f35'),
+ ('\u0f36', '\u0f36'), ('\u0f37', '\u0f37'), ('\u0f38', '\u0f38'), ('\u0f39', '\u0f39'),
+ ('\u0f3a', '\u0f3a'), ('\u0f3b', '\u0f3b'), ('\u0f3c', '\u0f3c'), ('\u0f3d', '\u0f3d'),
+ ('\u0f3e', '\u0f3f'), ('\u0f40', '\u0f47'), ('\u0f49', '\u0f6c'), ('\u0f71', '\u0f7e'),
+ ('\u0f7f', '\u0f7f'), ('\u0f80', '\u0f84'), ('\u0f85', '\u0f85'), ('\u0f86', '\u0f87'),
+ ('\u0f88', '\u0f8c'), ('\u0f8d', '\u0f97'), ('\u0f99', '\u0fbc'), ('\u0fbe', '\u0fc5'),
+ ('\u0fc6', '\u0fc6'), ('\u0fc7', '\u0fcc'), ('\u0fce', '\u0fcf'), ('\u0fd0', '\u0fd4'),
+ ('\u0fd9', '\u0fda')
+ ];
+
+ pub static Tifinagh_table: &'static [(char, char)] = &[
+ ('\u2d30', '\u2d67'), ('\u2d6f', '\u2d6f'), ('\u2d70', '\u2d70'), ('\u2d7f', '\u2d7f')
+ ];
+
+ pub static Tirhuta_table: &'static [(char, char)] = &[
+ ('\U00011480', '\U000114af'), ('\U000114b0', '\U000114b2'), ('\U000114b3', '\U000114b8'),
+ ('\U000114b9', '\U000114b9'), ('\U000114ba', '\U000114ba'), ('\U000114bb', '\U000114be'),
+ ('\U000114bf', '\U000114c0'), ('\U000114c1', '\U000114c1'), ('\U000114c2', '\U000114c3'),
+ ('\U000114c4', '\U000114c5'), ('\U000114c6', '\U000114c6'), ('\U000114c7', '\U000114c7'),
+ ('\U000114d0', '\U000114d9')
+ ];
+
+ pub static Ugaritic_table: &'static [(char, char)] = &[
+ ('\U00010380', '\U0001039d'), ('\U0001039f', '\U0001039f')
+ ];
+
+ pub static Vai_table: &'static [(char, char)] = &[
+ ('\ua500', '\ua60b'), ('\ua60c', '\ua60c'), ('\ua60d', '\ua60f'), ('\ua610', '\ua61f'),
+ ('\ua620', '\ua629'), ('\ua62a', '\ua62b')
+ ];
+
+ pub static Warang_Citi_table: &'static [(char, char)] = &[
+ ('\U000118a0', '\U000118df'), ('\U000118e0', '\U000118e9'), ('\U000118ea', '\U000118f2'),
+ ('\U000118ff', '\U000118ff')
+ ];
+
+ pub static Yi_table: &'static [(char, char)] = &[
+ ('\ua000', '\ua014'), ('\ua015', '\ua015'), ('\ua016', '\ua48c'), ('\ua490', '\ua4c6')
+ ];
+
+}
+
+pub mod property {
+ pub static Join_Control_table: &'static [(char, char)] = &[
+ ('\u200c', '\u200d')
+ ];
+
+ pub static White_Space_table: &'static [(char, char)] = &[
+ ('\x09', '\x0d'), ('\x20', '\x20'), ('\x85', '\x85'), ('\xa0', '\xa0'), ('\u1680',
+ '\u1680'), ('\u2000', '\u200a'), ('\u2028', '\u2028'), ('\u2029', '\u2029'), ('\u202f',
+ '\u202f'), ('\u205f', '\u205f'), ('\u3000', '\u3000')
+ ];
+
+ pub fn White_Space(c: char) -> bool {
+ super::bsearch_range_table(c, White_Space_table)
+ }
+
+}
+
+pub mod regex {
+ pub static UNICODE_CLASSES: &'static [(&'static str, &'static [(char, char)])] = &[
+ ("Alphabetic", super::derived_property::Alphabetic_table), ("Arabic",
+ super::script::Arabic_table), ("Armenian", super::script::Armenian_table), ("Avestan",
+ super::script::Avestan_table), ("Balinese", super::script::Balinese_table), ("Bamum",
+ super::script::Bamum_table), ("Bassa_Vah", super::script::Bassa_Vah_table), ("Batak",
+ super::script::Batak_table), ("Bengali", super::script::Bengali_table), ("Bopomofo",
+ super::script::Bopomofo_table), ("Brahmi", super::script::Brahmi_table), ("Braille",
+ super::script::Braille_table), ("Buginese", super::script::Buginese_table), ("Buhid",
+ super::script::Buhid_table), ("C", super::general_category::C_table),
+ ("Canadian_Aboriginal", super::script::Canadian_Aboriginal_table), ("Carian",
+ super::script::Carian_table), ("Caucasian_Albanian",
+ super::script::Caucasian_Albanian_table), ("Cc", super::general_category::Cc_table), ("Cf",
+ super::general_category::Cf_table), ("Chakma", super::script::Chakma_table), ("Cham",
+ super::script::Cham_table), ("Cherokee", super::script::Cherokee_table), ("Co",
+ super::general_category::Co_table), ("Common", super::script::Common_table), ("Coptic",
+ super::script::Coptic_table), ("Cuneiform", super::script::Cuneiform_table), ("Cypriot",
+ super::script::Cypriot_table), ("Cyrillic", super::script::Cyrillic_table), ("Deseret",
+ super::script::Deseret_table), ("Devanagari", super::script::Devanagari_table), ("Duployan",
+ super::script::Duployan_table), ("Egyptian_Hieroglyphs",
+ super::script::Egyptian_Hieroglyphs_table), ("Elbasan", super::script::Elbasan_table),
+ ("Ethiopic", super::script::Ethiopic_table), ("Georgian", super::script::Georgian_table),
+ ("Glagolitic", super::script::Glagolitic_table), ("Gothic", super::script::Gothic_table),
+ ("Grantha", super::script::Grantha_table), ("Greek", super::script::Greek_table),
+ ("Gujarati", super::script::Gujarati_table), ("Gurmukhi", super::script::Gurmukhi_table),
+ ("Han", super::script::Han_table), ("Hangul", super::script::Hangul_table), ("Hanunoo",
+ super::script::Hanunoo_table), ("Hebrew", super::script::Hebrew_table), ("Hiragana",
+ super::script::Hiragana_table), ("Imperial_Aramaic", super::script::Imperial_Aramaic_table),
+ ("Inherited", super::script::Inherited_table), ("Inscriptional_Pahlavi",
+ super::script::Inscriptional_Pahlavi_table), ("Inscriptional_Parthian",
+ super::script::Inscriptional_Parthian_table), ("Javanese", super::script::Javanese_table),
+ ("Join_Control", super::property::Join_Control_table), ("Kaithi",
+ super::script::Kaithi_table), ("Kannada", super::script::Kannada_table), ("Katakana",
+ super::script::Katakana_table), ("Kayah_Li", super::script::Kayah_Li_table), ("Kharoshthi",
+ super::script::Kharoshthi_table), ("Khmer", super::script::Khmer_table), ("Khojki",
+ super::script::Khojki_table), ("Khudawadi", super::script::Khudawadi_table), ("L",
+ super::general_category::L_table), ("LC", super::general_category::LC_table), ("Lao",
+ super::script::Lao_table), ("Latin", super::script::Latin_table), ("Lepcha",
+ super::script::Lepcha_table), ("Limbu", super::script::Limbu_table), ("Linear_A",
+ super::script::Linear_A_table), ("Linear_B", super::script::Linear_B_table), ("Lisu",
+ super::script::Lisu_table), ("Ll", super::general_category::Ll_table), ("Lm",
+ super::general_category::Lm_table), ("Lo", super::general_category::Lo_table), ("Lowercase",
+ super::derived_property::Lowercase_table), ("Lt", super::general_category::Lt_table), ("Lu",
+ super::general_category::Lu_table), ("Lycian", super::script::Lycian_table), ("Lydian",
+ super::script::Lydian_table), ("M", super::general_category::M_table), ("Mahajani",
+ super::script::Mahajani_table), ("Malayalam", super::script::Malayalam_table), ("Mandaic",
+ super::script::Mandaic_table), ("Manichaean", super::script::Manichaean_table), ("Mc",
+ super::general_category::Mc_table), ("Me", super::general_category::Me_table),
+ ("Meetei_Mayek", super::script::Meetei_Mayek_table), ("Mende_Kikakui",
+ super::script::Mende_Kikakui_table), ("Meroitic_Cursive",
+ super::script::Meroitic_Cursive_table), ("Meroitic_Hieroglyphs",
+ super::script::Meroitic_Hieroglyphs_table), ("Miao", super::script::Miao_table), ("Mn",
+ super::general_category::Mn_table), ("Modi", super::script::Modi_table), ("Mongolian",
+ super::script::Mongolian_table), ("Mro", super::script::Mro_table), ("Myanmar",
+ super::script::Myanmar_table), ("N", super::general_category::N_table), ("Nabataean",
+ super::script::Nabataean_table), ("Nd", super::general_category::Nd_table), ("New_Tai_Lue",
+ super::script::New_Tai_Lue_table), ("Nko", super::script::Nko_table), ("Nl",
+ super::general_category::Nl_table), ("No", super::general_category::No_table), ("Ogham",
+ super::script::Ogham_table), ("Ol_Chiki", super::script::Ol_Chiki_table), ("Old_Italic",
+ super::script::Old_Italic_table), ("Old_North_Arabian",
+ super::script::Old_North_Arabian_table), ("Old_Permic", super::script::Old_Permic_table),
+ ("Old_Persian", super::script::Old_Persian_table), ("Old_South_Arabian",
+ super::script::Old_South_Arabian_table), ("Old_Turkic", super::script::Old_Turkic_table),
+ ("Oriya", super::script::Oriya_table), ("Osmanya", super::script::Osmanya_table), ("P",
+ super::general_category::P_table), ("Pahawh_Hmong", super::script::Pahawh_Hmong_table),
+ ("Palmyrene", super::script::Palmyrene_table), ("Pau_Cin_Hau",
+ super::script::Pau_Cin_Hau_table), ("Pc", super::general_category::Pc_table), ("Pd",
+ super::general_category::Pd_table), ("Pe", super::general_category::Pe_table), ("Pf",
+ super::general_category::Pf_table), ("Phags_Pa", super::script::Phags_Pa_table),
+ ("Phoenician", super::script::Phoenician_table), ("Pi", super::general_category::Pi_table),
+ ("Po", super::general_category::Po_table), ("Ps", super::general_category::Ps_table),
+ ("Psalter_Pahlavi", super::script::Psalter_Pahlavi_table), ("Rejang",
+ super::script::Rejang_table), ("Runic", super::script::Runic_table), ("S",
+ super::general_category::S_table), ("Samaritan", super::script::Samaritan_table),
+ ("Saurashtra", super::script::Saurashtra_table), ("Sc", super::general_category::Sc_table),
+ ("Sharada", super::script::Sharada_table), ("Shavian", super::script::Shavian_table),
+ ("Siddham", super::script::Siddham_table), ("Sinhala", super::script::Sinhala_table), ("Sk",
+ super::general_category::Sk_table), ("Sm", super::general_category::Sm_table), ("So",
+ super::general_category::So_table), ("Sora_Sompeng", super::script::Sora_Sompeng_table),
+ ("Sundanese", super::script::Sundanese_table), ("Syloti_Nagri",
+ super::script::Syloti_Nagri_table), ("Syriac", super::script::Syriac_table), ("Tagalog",
+ super::script::Tagalog_table), ("Tagbanwa", super::script::Tagbanwa_table), ("Tai_Le",
+ super::script::Tai_Le_table), ("Tai_Tham", super::script::Tai_Tham_table), ("Tai_Viet",
+ super::script::Tai_Viet_table), ("Takri", super::script::Takri_table), ("Tamil",
+ super::script::Tamil_table), ("Telugu", super::script::Telugu_table), ("Thaana",
+ super::script::Thaana_table), ("Thai", super::script::Thai_table), ("Tibetan",
+ super::script::Tibetan_table), ("Tifinagh", super::script::Tifinagh_table), ("Tirhuta",
+ super::script::Tirhuta_table), ("Ugaritic", super::script::Ugaritic_table), ("Uppercase",
+ super::derived_property::Uppercase_table), ("Vai", super::script::Vai_table),
+ ("Warang_Citi", super::script::Warang_Citi_table), ("White_Space",
+ super::property::White_Space_table), ("XID_Continue",
+ super::derived_property::XID_Continue_table), ("XID_Start",
+ super::derived_property::XID_Start_table), ("Yi", super::script::Yi_table), ("Z",
+ super::general_category::Z_table), ("Zl", super::general_category::Zl_table), ("Zp",
+ super::general_category::Zp_table), ("Zs", super::general_category::Zs_table)
+ ];
+
+ pub static PERLD: &'static [(char, char)] = super::general_category::Nd_table;
+
+ pub static PERLS: &'static [(char, char)] = super::property::White_Space_table;
+
+ pub static PERLW: &'static [(char, char)] = &[
+ ('\x30', '\x39'), ('\x41', '\x5a'), ('\x5f', '\x5f'), ('\x61', '\x7a'), ('\xaa', '\xaa'),
+ ('\xb5', '\xb5'), ('\xba', '\xba'), ('\xc0', '\xd6'), ('\xd8', '\xf6'), ('\xf8', '\u02c1'),
+ ('\u02c6', '\u02d1'), ('\u02e0', '\u02e4'), ('\u02ec', '\u02ec'), ('\u02ee', '\u02ee'),
+ ('\u0300', '\u0374'), ('\u0376', '\u0377'), ('\u037a', '\u037d'), ('\u037f', '\u037f'),
+ ('\u0386', '\u0386'), ('\u0388', '\u038a'), ('\u038c', '\u038c'), ('\u038e', '\u03a1'),
+ ('\u03a3', '\u03f5'), ('\u03f7', '\u0481'), ('\u0483', '\u052f'), ('\u0531', '\u0556'),
+ ('\u0559', '\u0559'), ('\u0561', '\u0587'), ('\u0591', '\u05bd'), ('\u05bf', '\u05bf'),
+ ('\u05c1', '\u05c2'), ('\u05c4', '\u05c5'), ('\u05c7', '\u05c7'), ('\u05d0', '\u05ea'),
+ ('\u05f0', '\u05f2'), ('\u0610', '\u061a'), ('\u0620', '\u0669'), ('\u066e', '\u06d3'),
+ ('\u06d5', '\u06dc'), ('\u06df', '\u06e8'), ('\u06ea', '\u06fc'), ('\u06ff', '\u06ff'),
+ ('\u0710', '\u074a'), ('\u074d', '\u07b1'), ('\u07c0', '\u07f5'), ('\u07fa', '\u07fa'),
+ ('\u0800', '\u082d'), ('\u0840', '\u085b'), ('\u08a0', '\u08b2'), ('\u08e4', '\u0963'),
+ ('\u0966', '\u096f'), ('\u0971', '\u0983'), ('\u0985', '\u098c'), ('\u098f', '\u0990'),
+ ('\u0993', '\u09a8'), ('\u09aa', '\u09b0'), ('\u09b2', '\u09b2'), ('\u09b6', '\u09b9'),
+ ('\u09bc', '\u09c4'), ('\u09c7', '\u09c8'), ('\u09cb', '\u09ce'), ('\u09d7', '\u09d7'),
+ ('\u09dc', '\u09dd'), ('\u09df', '\u09e3'), ('\u09e6', '\u09f1'), ('\u0a01', '\u0a03'),
+ ('\u0a05', '\u0a0a'), ('\u0a0f', '\u0a10'), ('\u0a13', '\u0a28'), ('\u0a2a', '\u0a30'),
+ ('\u0a32', '\u0a33'), ('\u0a35', '\u0a36'), ('\u0a38', '\u0a39'), ('\u0a3c', '\u0a3c'),
+ ('\u0a3e', '\u0a42'), ('\u0a47', '\u0a48'), ('\u0a4b', '\u0a4d'), ('\u0a51', '\u0a51'),
+ ('\u0a59', '\u0a5c'), ('\u0a5e', '\u0a5e'), ('\u0a66', '\u0a75'), ('\u0a81', '\u0a83'),
+ ('\u0a85', '\u0a8d'), ('\u0a8f', '\u0a91'), ('\u0a93', '\u0aa8'), ('\u0aaa', '\u0ab0'),
+ ('\u0ab2', '\u0ab3'), ('\u0ab5', '\u0ab9'), ('\u0abc', '\u0ac5'), ('\u0ac7', '\u0ac9'),
+ ('\u0acb', '\u0acd'), ('\u0ad0', '\u0ad0'), ('\u0ae0', '\u0ae3'), ('\u0ae6', '\u0aef'),
+ ('\u0b01', '\u0b03'), ('\u0b05', '\u0b0c'), ('\u0b0f', '\u0b10'), ('\u0b13', '\u0b28'),
+ ('\u0b2a', '\u0b30'), ('\u0b32', '\u0b33'), ('\u0b35', '\u0b39'), ('\u0b3c', '\u0b44'),
+ ('\u0b47', '\u0b48'), ('\u0b4b', '\u0b4d'), ('\u0b56', '\u0b57'), ('\u0b5c', '\u0b5d'),
+ ('\u0b5f', '\u0b63'), ('\u0b66', '\u0b6f'), ('\u0b71', '\u0b71'), ('\u0b82', '\u0b83'),
+ ('\u0b85', '\u0b8a'), ('\u0b8e', '\u0b90'), ('\u0b92', '\u0b95'), ('\u0b99', '\u0b9a'),
+ ('\u0b9c', '\u0b9c'), ('\u0b9e', '\u0b9f'), ('\u0ba3', '\u0ba4'), ('\u0ba8', '\u0baa'),
+ ('\u0bae', '\u0bb9'), ('\u0bbe', '\u0bc2'), ('\u0bc6', '\u0bc8'), ('\u0bca', '\u0bcd'),
+ ('\u0bd0', '\u0bd0'), ('\u0bd7', '\u0bd7'), ('\u0be6', '\u0bef'), ('\u0c00', '\u0c03'),
+ ('\u0c05', '\u0c0c'), ('\u0c0e', '\u0c10'), ('\u0c12', '\u0c28'), ('\u0c2a', '\u0c39'),
+ ('\u0c3d', '\u0c44'), ('\u0c46', '\u0c48'), ('\u0c4a', '\u0c4d'), ('\u0c55', '\u0c56'),
+ ('\u0c58', '\u0c59'), ('\u0c60', '\u0c63'), ('\u0c66', '\u0c6f'), ('\u0c81', '\u0c83'),
+ ('\u0c85', '\u0c8c'), ('\u0c8e', '\u0c90'), ('\u0c92', '\u0ca8'), ('\u0caa', '\u0cb3'),
+ ('\u0cb5', '\u0cb9'), ('\u0cbc', '\u0cc4'), ('\u0cc6', '\u0cc8'), ('\u0cca', '\u0ccd'),
+ ('\u0cd5', '\u0cd6'), ('\u0cde', '\u0cde'), ('\u0ce0', '\u0ce3'), ('\u0ce6', '\u0cef'),
+ ('\u0cf1', '\u0cf2'), ('\u0d01', '\u0d03'), ('\u0d05', '\u0d0c'), ('\u0d0e', '\u0d10'),
+ ('\u0d12', '\u0d3a'), ('\u0d3d', '\u0d44'), ('\u0d46', '\u0d48'), ('\u0d4a', '\u0d4e'),
+ ('\u0d57', '\u0d57'), ('\u0d60', '\u0d63'), ('\u0d66', '\u0d6f'), ('\u0d7a', '\u0d7f'),
+ ('\u0d82', '\u0d83'), ('\u0d85', '\u0d96'), ('\u0d9a', '\u0db1'), ('\u0db3', '\u0dbb'),
+ ('\u0dbd', '\u0dbd'), ('\u0dc0', '\u0dc6'), ('\u0dca', '\u0dca'), ('\u0dcf', '\u0dd4'),
+ ('\u0dd6', '\u0dd6'), ('\u0dd8', '\u0ddf'), ('\u0de6', '\u0def'), ('\u0df2', '\u0df3'),
+ ('\u0e01', '\u0e3a'), ('\u0e40', '\u0e4e'), ('\u0e50', '\u0e59'), ('\u0e81', '\u0e82'),
+ ('\u0e84', '\u0e84'), ('\u0e87', '\u0e88'), ('\u0e8a', '\u0e8a'), ('\u0e8d', '\u0e8d'),
+ ('\u0e94', '\u0e97'), ('\u0e99', '\u0e9f'), ('\u0ea1', '\u0ea3'), ('\u0ea5', '\u0ea5'),
+ ('\u0ea7', '\u0ea7'), ('\u0eaa', '\u0eab'), ('\u0ead', '\u0eb9'), ('\u0ebb', '\u0ebd'),
+ ('\u0ec0', '\u0ec4'), ('\u0ec6', '\u0ec6'), ('\u0ec8', '\u0ecd'), ('\u0ed0', '\u0ed9'),
+ ('\u0edc', '\u0edf'), ('\u0f00', '\u0f00'), ('\u0f18', '\u0f19'), ('\u0f20', '\u0f29'),
+ ('\u0f35', '\u0f35'), ('\u0f37', '\u0f37'), ('\u0f39', '\u0f39'), ('\u0f3e', '\u0f47'),
+ ('\u0f49', '\u0f6c'), ('\u0f71', '\u0f84'), ('\u0f86', '\u0f97'), ('\u0f99', '\u0fbc'),
+ ('\u0fc6', '\u0fc6'), ('\u1000', '\u1049'), ('\u1050', '\u109d'), ('\u10a0', '\u10c5'),
+ ('\u10c7', '\u10c7'), ('\u10cd', '\u10cd'), ('\u10d0', '\u10fa'), ('\u10fc', '\u1248'),
+ ('\u124a', '\u124d'), ('\u1250', '\u1256'), ('\u1258', '\u1258'), ('\u125a', '\u125d'),
+ ('\u1260', '\u1288'), ('\u128a', '\u128d'), ('\u1290', '\u12b0'), ('\u12b2', '\u12b5'),
+ ('\u12b8', '\u12be'), ('\u12c0', '\u12c0'), ('\u12c2', '\u12c5'), ('\u12c8', '\u12d6'),
+ ('\u12d8', '\u1310'), ('\u1312', '\u1315'), ('\u1318', '\u135a'), ('\u135d', '\u135f'),
+ ('\u1380', '\u138f'), ('\u13a0', '\u13f4'), ('\u1401', '\u166c'), ('\u166f', '\u167f'),
+ ('\u1681', '\u169a'), ('\u16a0', '\u16ea'), ('\u16ee', '\u16f8'), ('\u1700', '\u170c'),
+ ('\u170e', '\u1714'), ('\u1720', '\u1734'), ('\u1740', '\u1753'), ('\u1760', '\u176c'),
+ ('\u176e', '\u1770'), ('\u1772', '\u1773'), ('\u1780', '\u17d3'), ('\u17d7', '\u17d7'),
+ ('\u17dc', '\u17dd'), ('\u17e0', '\u17e9'), ('\u180b', '\u180d'), ('\u1810', '\u1819'),
+ ('\u1820', '\u1877'), ('\u1880', '\u18aa'), ('\u18b0', '\u18f5'), ('\u1900', '\u191e'),
+ ('\u1920', '\u192b'), ('\u1930', '\u193b'), ('\u1946', '\u196d'), ('\u1970', '\u1974'),
+ ('\u1980', '\u19ab'), ('\u19b0', '\u19c9'), ('\u19d0', '\u19d9'), ('\u1a00', '\u1a1b'),
+ ('\u1a20', '\u1a5e'), ('\u1a60', '\u1a7c'), ('\u1a7f', '\u1a89'), ('\u1a90', '\u1a99'),
+ ('\u1aa7', '\u1aa7'), ('\u1ab0', '\u1abe'), ('\u1b00', '\u1b4b'), ('\u1b50', '\u1b59'),
+ ('\u1b6b', '\u1b73'), ('\u1b80', '\u1bf3'), ('\u1c00', '\u1c37'), ('\u1c40', '\u1c49'),
+ ('\u1c4d', '\u1c7d'), ('\u1cd0', '\u1cd2'), ('\u1cd4', '\u1cf6'), ('\u1cf8', '\u1cf9'),
+ ('\u1d00', '\u1df5'), ('\u1dfc', '\u1f15'), ('\u1f18', '\u1f1d'), ('\u1f20', '\u1f45'),
+ ('\u1f48', '\u1f4d'), ('\u1f50', '\u1f57'), ('\u1f59', '\u1f59'), ('\u1f5b', '\u1f5b'),
+ ('\u1f5d', '\u1f5d'), ('\u1f5f', '\u1f7d'), ('\u1f80', '\u1fb4'), ('\u1fb6', '\u1fbc'),
+ ('\u1fbe', '\u1fbe'), ('\u1fc2', '\u1fc4'), ('\u1fc6', '\u1fcc'), ('\u1fd0', '\u1fd3'),
+ ('\u1fd6', '\u1fdb'), ('\u1fe0', '\u1fec'), ('\u1ff2', '\u1ff4'), ('\u1ff6', '\u1ffc'),
+ ('\u200c', '\u200d'), ('\u203f', '\u2040'), ('\u2054', '\u2054'), ('\u2071', '\u2071'),
+ ('\u207f', '\u207f'), ('\u2090', '\u209c'), ('\u20d0', '\u20f0'), ('\u2102', '\u2102'),
+ ('\u2107', '\u2107'), ('\u210a', '\u2113'), ('\u2115', '\u2115'), ('\u2119', '\u211d'),
+ ('\u2124', '\u2124'), ('\u2126', '\u2126'), ('\u2128', '\u2128'), ('\u212a', '\u212d'),
+ ('\u212f', '\u2139'), ('\u213c', '\u213f'), ('\u2145', '\u2149'), ('\u214e', '\u214e'),
+ ('\u2160', '\u2188'), ('\u24b6', '\u24e9'), ('\u2c00', '\u2c2e'), ('\u2c30', '\u2c5e'),
+ ('\u2c60', '\u2ce4'), ('\u2ceb', '\u2cf3'), ('\u2d00', '\u2d25'), ('\u2d27', '\u2d27'),
+ ('\u2d2d', '\u2d2d'), ('\u2d30', '\u2d67'), ('\u2d6f', '\u2d6f'), ('\u2d7f', '\u2d96'),
+ ('\u2da0', '\u2da6'), ('\u2da8', '\u2dae'), ('\u2db0', '\u2db6'), ('\u2db8', '\u2dbe'),
+ ('\u2dc0', '\u2dc6'), ('\u2dc8', '\u2dce'), ('\u2dd0', '\u2dd6'), ('\u2dd8', '\u2dde'),
+ ('\u2de0', '\u2dff'), ('\u2e2f', '\u2e2f'), ('\u3005', '\u3007'), ('\u3021', '\u302f'),
+ ('\u3031', '\u3035'), ('\u3038', '\u303c'), ('\u3041', '\u3096'), ('\u3099', '\u309a'),
+ ('\u309d', '\u309f'), ('\u30a1', '\u30fa'), ('\u30fc', '\u30ff'), ('\u3105', '\u312d'),
+ ('\u3131', '\u318e'), ('\u31a0', '\u31ba'), ('\u31f0', '\u31ff'), ('\u3400', '\u4db5'),
+ ('\u4e00', '\u9fcc'), ('\ua000', '\ua48c'), ('\ua4d0', '\ua4fd'), ('\ua500', '\ua60c'),
+ ('\ua610', '\ua62b'), ('\ua640', '\ua672'), ('\ua674', '\ua67d'), ('\ua67f', '\ua69d'),
+ ('\ua69f', '\ua6f1'), ('\ua717', '\ua71f'), ('\ua722', '\ua788'), ('\ua78b', '\ua78e'),
+ ('\ua790', '\ua7ad'), ('\ua7b0', '\ua7b1'), ('\ua7f7', '\ua827'), ('\ua840', '\ua873'),
+ ('\ua880', '\ua8c4'), ('\ua8d0', '\ua8d9'), ('\ua8e0', '\ua8f7'), ('\ua8fb', '\ua8fb'),
+ ('\ua900', '\ua92d'), ('\ua930', '\ua953'), ('\ua960', '\ua97c'), ('\ua980', '\ua9c0'),
+ ('\ua9cf', '\ua9d9'), ('\ua9e0', '\ua9fe'), ('\uaa00', '\uaa36'), ('\uaa40', '\uaa4d'),
+ ('\uaa50', '\uaa59'), ('\uaa60', '\uaa76'), ('\uaa7a', '\uaac2'), ('\uaadb', '\uaadd'),
+ ('\uaae0', '\uaaef'), ('\uaaf2', '\uaaf6'), ('\uab01', '\uab06'), ('\uab09', '\uab0e'),
+ ('\uab11', '\uab16'), ('\uab20', '\uab26'), ('\uab28', '\uab2e'), ('\uab30', '\uab5a'),
+ ('\uab5c', '\uab5f'), ('\uab64', '\uab65'), ('\uabc0', '\uabea'), ('\uabec', '\uabed'),
+ ('\uabf0', '\uabf9'), ('\uac00', '\ud7a3'), ('\ud7b0', '\ud7c6'), ('\ud7cb', '\ud7fb'),
+ ('\uf900', '\ufa6d'), ('\ufa70', '\ufad9'), ('\ufb00', '\ufb06'), ('\ufb13', '\ufb17'),
+ ('\ufb1d', '\ufb28'), ('\ufb2a', '\ufb36'), ('\ufb38', '\ufb3c'), ('\ufb3e', '\ufb3e'),
+ ('\ufb40', '\ufb41'), ('\ufb43', '\ufb44'), ('\ufb46', '\ufbb1'), ('\ufbd3', '\ufd3d'),
+ ('\ufd50', '\ufd8f'), ('\ufd92', '\ufdc7'), ('\ufdf0', '\ufdfb'), ('\ufe00', '\ufe0f'),
+ ('\ufe20', '\ufe2d'), ('\ufe33', '\ufe34'), ('\ufe4d', '\ufe4f'), ('\ufe70', '\ufe74'),
+ ('\ufe76', '\ufefc'), ('\uff10', '\uff19'), ('\uff21', '\uff3a'), ('\uff3f', '\uff3f'),
+ ('\uff41', '\uff5a'), ('\uff66', '\uffbe'), ('\uffc2', '\uffc7'), ('\uffca', '\uffcf'),
+ ('\uffd2', '\uffd7'), ('\uffda', '\uffdc'), ('\U00010000', '\U0001000b'), ('\U0001000d',
+ '\U00010026'), ('\U00010028', '\U0001003a'), ('\U0001003c', '\U0001003d'), ('\U0001003f',
+ '\U0001004d'), ('\U00010050', '\U0001005d'), ('\U00010080', '\U000100fa'), ('\U00010140',
+ '\U00010174'), ('\U000101fd', '\U000101fd'), ('\U00010280', '\U0001029c'), ('\U000102a0',
+ '\U000102d0'), ('\U000102e0', '\U000102e0'), ('\U00010300', '\U0001031f'), ('\U00010330',
+ '\U0001034a'), ('\U00010350', '\U0001037a'), ('\U00010380', '\U0001039d'), ('\U000103a0',
+ '\U000103c3'), ('\U000103c8', '\U000103cf'), ('\U000103d1', '\U000103d5'), ('\U00010400',
+ '\U0001049d'), ('\U000104a0', '\U000104a9'), ('\U00010500', '\U00010527'), ('\U00010530',
+ '\U00010563'), ('\U00010600', '\U00010736'), ('\U00010740', '\U00010755'), ('\U00010760',
+ '\U00010767'), ('\U00010800', '\U00010805'), ('\U00010808', '\U00010808'), ('\U0001080a',
+ '\U00010835'), ('\U00010837', '\U00010838'), ('\U0001083c', '\U0001083c'), ('\U0001083f',
+ '\U00010855'), ('\U00010860', '\U00010876'), ('\U00010880', '\U0001089e'), ('\U00010900',
+ '\U00010915'), ('\U00010920', '\U00010939'), ('\U00010980', '\U000109b7'), ('\U000109be',
+ '\U000109bf'), ('\U00010a00', '\U00010a03'), ('\U00010a05', '\U00010a06'), ('\U00010a0c',
+ '\U00010a13'), ('\U00010a15', '\U00010a17'), ('\U00010a19', '\U00010a33'), ('\U00010a38',
+ '\U00010a3a'), ('\U00010a3f', '\U00010a3f'), ('\U00010a60', '\U00010a7c'), ('\U00010a80',
+ '\U00010a9c'), ('\U00010ac0', '\U00010ac7'), ('\U00010ac9', '\U00010ae6'), ('\U00010b00',
+ '\U00010b35'), ('\U00010b40', '\U00010b55'), ('\U00010b60', '\U00010b72'), ('\U00010b80',
+ '\U00010b91'), ('\U00010c00', '\U00010c48'), ('\U00011000', '\U00011046'), ('\U00011066',
+ '\U0001106f'), ('\U0001107f', '\U000110ba'), ('\U000110d0', '\U000110e8'), ('\U000110f0',
+ '\U000110f9'), ('\U00011100', '\U00011134'), ('\U00011136', '\U0001113f'), ('\U00011150',
+ '\U00011173'), ('\U00011176', '\U00011176'), ('\U00011180', '\U000111c4'), ('\U000111d0',
+ '\U000111da'), ('\U00011200', '\U00011211'), ('\U00011213', '\U00011237'), ('\U000112b0',
+ '\U000112ea'), ('\U000112f0', '\U000112f9'), ('\U00011301', '\U00011303'), ('\U00011305',
+ '\U0001130c'), ('\U0001130f', '\U00011310'), ('\U00011313', '\U00011328'), ('\U0001132a',
+ '\U00011330'), ('\U00011332', '\U00011333'), ('\U00011335', '\U00011339'), ('\U0001133c',
+ '\U00011344'), ('\U00011347', '\U00011348'), ('\U0001134b', '\U0001134d'), ('\U00011357',
+ '\U00011357'), ('\U0001135d', '\U00011363'), ('\U00011366', '\U0001136c'), ('\U00011370',
+ '\U00011374'), ('\U00011480', '\U000114c5'), ('\U000114c7', '\U000114c7'), ('\U000114d0',
+ '\U000114d9'), ('\U00011580', '\U000115b5'), ('\U000115b8', '\U000115c0'), ('\U00011600',
+ '\U00011640'), ('\U00011644', '\U00011644'), ('\U00011650', '\U00011659'), ('\U00011680',
+ '\U000116b7'), ('\U000116c0', '\U000116c9'), ('\U000118a0', '\U000118e9'), ('\U000118ff',
+ '\U000118ff'), ('\U00011ac0', '\U00011af8'), ('\U00012000', '\U00012398'), ('\U00012400',
+ '\U0001246e'), ('\U00013000', '\U0001342e'), ('\U00016800', '\U00016a38'), ('\U00016a40',
+ '\U00016a5e'), ('\U00016a60', '\U00016a69'), ('\U00016ad0', '\U00016aed'), ('\U00016af0',
+ '\U00016af4'), ('\U00016b00', '\U00016b36'), ('\U00016b40', '\U00016b43'), ('\U00016b50',
+ '\U00016b59'), ('\U00016b63', '\U00016b77'), ('\U00016b7d', '\U00016b8f'), ('\U00016f00',
+ '\U00016f44'), ('\U00016f50', '\U00016f7e'), ('\U00016f8f', '\U00016f9f'), ('\U0001b000',
+ '\U0001b001'), ('\U0001bc00', '\U0001bc6a'), ('\U0001bc70', '\U0001bc7c'), ('\U0001bc80',
+ '\U0001bc88'), ('\U0001bc90', '\U0001bc99'), ('\U0001bc9d', '\U0001bc9e'), ('\U0001d165',
+ '\U0001d169'), ('\U0001d16d', '\U0001d172'), ('\U0001d17b', '\U0001d182'), ('\U0001d185',
+ '\U0001d18b'), ('\U0001d1aa', '\U0001d1ad'), ('\U0001d242', '\U0001d244'), ('\U0001d400',
+ '\U0001d454'), ('\U0001d456', '\U0001d49c'), ('\U0001d49e', '\U0001d49f'), ('\U0001d4a2',
+ '\U0001d4a2'), ('\U0001d4a5', '\U0001d4a6'), ('\U0001d4a9', '\U0001d4ac'), ('\U0001d4ae',
+ '\U0001d4b9'), ('\U0001d4bb', '\U0001d4bb'), ('\U0001d4bd', '\U0001d4c3'), ('\U0001d4c5',
+ '\U0001d505'), ('\U0001d507', '\U0001d50a'), ('\U0001d50d', '\U0001d514'), ('\U0001d516',
+ '\U0001d51c'), ('\U0001d51e', '\U0001d539'), ('\U0001d53b', '\U0001d53e'), ('\U0001d540',
+ '\U0001d544'), ('\U0001d546', '\U0001d546'), ('\U0001d54a', '\U0001d550'), ('\U0001d552',
+ '\U0001d6a5'), ('\U0001d6a8', '\U0001d6c0'), ('\U0001d6c2', '\U0001d6da'), ('\U0001d6dc',
+ '\U0001d6fa'), ('\U0001d6fc', '\U0001d714'), ('\U0001d716', '\U0001d734'), ('\U0001d736',
+ '\U0001d74e'), ('\U0001d750', '\U0001d76e'), ('\U0001d770', '\U0001d788'), ('\U0001d78a',
+ '\U0001d7a8'), ('\U0001d7aa', '\U0001d7c2'), ('\U0001d7c4', '\U0001d7cb'), ('\U0001d7ce',
+ '\U0001d7ff'), ('\U0001e800', '\U0001e8c4'), ('\U0001e8d0', '\U0001e8d6'), ('\U0001ee00',
+ '\U0001ee03'), ('\U0001ee05', '\U0001ee1f'), ('\U0001ee21', '\U0001ee22'), ('\U0001ee24',
+ '\U0001ee24'), ('\U0001ee27', '\U0001ee27'), ('\U0001ee29', '\U0001ee32'), ('\U0001ee34',
+ '\U0001ee37'), ('\U0001ee39', '\U0001ee39'), ('\U0001ee3b', '\U0001ee3b'), ('\U0001ee42',
+ '\U0001ee42'), ('\U0001ee47', '\U0001ee47'), ('\U0001ee49', '\U0001ee49'), ('\U0001ee4b',
+ '\U0001ee4b'), ('\U0001ee4d', '\U0001ee4f'), ('\U0001ee51', '\U0001ee52'), ('\U0001ee54',
+ '\U0001ee54'), ('\U0001ee57', '\U0001ee57'), ('\U0001ee59', '\U0001ee59'), ('\U0001ee5b',
+ '\U0001ee5b'), ('\U0001ee5d', '\U0001ee5d'), ('\U0001ee5f', '\U0001ee5f'), ('\U0001ee61',
+ '\U0001ee62'), ('\U0001ee64', '\U0001ee64'), ('\U0001ee67', '\U0001ee6a'), ('\U0001ee6c',
+ '\U0001ee72'), ('\U0001ee74', '\U0001ee77'), ('\U0001ee79', '\U0001ee7c'), ('\U0001ee7e',
+ '\U0001ee7e'), ('\U0001ee80', '\U0001ee89'), ('\U0001ee8b', '\U0001ee9b'), ('\U0001eea1',
+ '\U0001eea3'), ('\U0001eea5', '\U0001eea9'), ('\U0001eeab', '\U0001eebb'), ('\U0001f130',
+ '\U0001f149'), ('\U0001f150', '\U0001f169'), ('\U0001f170', '\U0001f189'), ('\U00020000',
+ '\U0002a6d6'), ('\U0002a700', '\U0002b734'), ('\U0002b740', '\U0002b81d'), ('\U0002f800',
+ '\U0002fa1d'), ('\U000e0100', '\U000e01ef')
+ ];
+
+}
+
+pub mod normalization {
+ // Canonical decompositions
+ pub static canonical_table: &'static [(char, &'static [char])] = &[
+ ('\xc0', &['\x41', '\u0300']), ('\xc1', &['\x41', '\u0301']), ('\xc2', &['\x41', '\u0302']),
+ ('\xc3', &['\x41', '\u0303']), ('\xc4', &['\x41', '\u0308']), ('\xc5', &['\x41', '\u030a']),
+ ('\xc7', &['\x43', '\u0327']), ('\xc8', &['\x45', '\u0300']), ('\xc9', &['\x45', '\u0301']),
+ ('\xca', &['\x45', '\u0302']), ('\xcb', &['\x45', '\u0308']), ('\xcc', &['\x49', '\u0300']),
+ ('\xcd', &['\x49', '\u0301']), ('\xce', &['\x49', '\u0302']), ('\xcf', &['\x49', '\u0308']),
+ ('\xd1', &['\x4e', '\u0303']), ('\xd2', &['\x4f', '\u0300']), ('\xd3', &['\x4f', '\u0301']),
+ ('\xd4', &['\x4f', '\u0302']), ('\xd5', &['\x4f', '\u0303']), ('\xd6', &['\x4f', '\u0308']),
+ ('\xd9', &['\x55', '\u0300']), ('\xda', &['\x55', '\u0301']), ('\xdb', &['\x55', '\u0302']),
+ ('\xdc', &['\x55', '\u0308']), ('\xdd', &['\x59', '\u0301']), ('\xe0', &['\x61', '\u0300']),
+ ('\xe1', &['\x61', '\u0301']), ('\xe2', &['\x61', '\u0302']), ('\xe3', &['\x61', '\u0303']),
+ ('\xe4', &['\x61', '\u0308']), ('\xe5', &['\x61', '\u030a']), ('\xe7', &['\x63', '\u0327']),
+ ('\xe8', &['\x65', '\u0300']), ('\xe9', &['\x65', '\u0301']), ('\xea', &['\x65', '\u0302']),
+ ('\xeb', &['\x65', '\u0308']), ('\xec', &['\x69', '\u0300']), ('\xed', &['\x69', '\u0301']),
+ ('\xee', &['\x69', '\u0302']), ('\xef', &['\x69', '\u0308']), ('\xf1', &['\x6e', '\u0303']),
+ ('\xf2', &['\x6f', '\u0300']), ('\xf3', &['\x6f', '\u0301']), ('\xf4', &['\x6f', '\u0302']),
+ ('\xf5', &['\x6f', '\u0303']), ('\xf6', &['\x6f', '\u0308']), ('\xf9', &['\x75', '\u0300']),
+ ('\xfa', &['\x75', '\u0301']), ('\xfb', &['\x75', '\u0302']), ('\xfc', &['\x75', '\u0308']),
+ ('\xfd', &['\x79', '\u0301']), ('\xff', &['\x79', '\u0308']), ('\u0100', &['\x41',
+ '\u0304']), ('\u0101', &['\x61', '\u0304']), ('\u0102', &['\x41', '\u0306']), ('\u0103',
+ &['\x61', '\u0306']), ('\u0104', &['\x41', '\u0328']), ('\u0105', &['\x61', '\u0328']),
+ ('\u0106', &['\x43', '\u0301']), ('\u0107', &['\x63', '\u0301']), ('\u0108', &['\x43',
+ '\u0302']), ('\u0109', &['\x63', '\u0302']), ('\u010a', &['\x43', '\u0307']), ('\u010b',
+ &['\x63', '\u0307']), ('\u010c', &['\x43', '\u030c']), ('\u010d', &['\x63', '\u030c']),
+ ('\u010e', &['\x44', '\u030c']), ('\u010f', &['\x64', '\u030c']), ('\u0112', &['\x45',
+ '\u0304']), ('\u0113', &['\x65', '\u0304']), ('\u0114', &['\x45', '\u0306']), ('\u0115',
+ &['\x65', '\u0306']), ('\u0116', &['\x45', '\u0307']), ('\u0117', &['\x65', '\u0307']),
+ ('\u0118', &['\x45', '\u0328']), ('\u0119', &['\x65', '\u0328']), ('\u011a', &['\x45',
+ '\u030c']), ('\u011b', &['\x65', '\u030c']), ('\u011c', &['\x47', '\u0302']), ('\u011d',
+ &['\x67', '\u0302']), ('\u011e', &['\x47', '\u0306']), ('\u011f', &['\x67', '\u0306']),
+ ('\u0120', &['\x47', '\u0307']), ('\u0121', &['\x67', '\u0307']), ('\u0122', &['\x47',
+ '\u0327']), ('\u0123', &['\x67', '\u0327']), ('\u0124', &['\x48', '\u0302']), ('\u0125',
+ &['\x68', '\u0302']), ('\u0128', &['\x49', '\u0303']), ('\u0129', &['\x69', '\u0303']),
+ ('\u012a', &['\x49', '\u0304']), ('\u012b', &['\x69', '\u0304']), ('\u012c', &['\x49',
+ '\u0306']), ('\u012d', &['\x69', '\u0306']), ('\u012e', &['\x49', '\u0328']), ('\u012f',
+ &['\x69', '\u0328']), ('\u0130', &['\x49', '\u0307']), ('\u0134', &['\x4a', '\u0302']),
+ ('\u0135', &['\x6a', '\u0302']), ('\u0136', &['\x4b', '\u0327']), ('\u0137', &['\x6b',
+ '\u0327']), ('\u0139', &['\x4c', '\u0301']), ('\u013a', &['\x6c', '\u0301']), ('\u013b',
+ &['\x4c', '\u0327']), ('\u013c', &['\x6c', '\u0327']), ('\u013d', &['\x4c', '\u030c']),
+ ('\u013e', &['\x6c', '\u030c']), ('\u0143', &['\x4e', '\u0301']), ('\u0144', &['\x6e',
+ '\u0301']), ('\u0145', &['\x4e', '\u0327']), ('\u0146', &['\x6e', '\u0327']), ('\u0147',
+ &['\x4e', '\u030c']), ('\u0148', &['\x6e', '\u030c']), ('\u014c', &['\x4f', '\u0304']),
+ ('\u014d', &['\x6f', '\u0304']), ('\u014e', &['\x4f', '\u0306']), ('\u014f', &['\x6f',
+ '\u0306']), ('\u0150', &['\x4f', '\u030b']), ('\u0151', &['\x6f', '\u030b']), ('\u0154',
+ &['\x52', '\u0301']), ('\u0155', &['\x72', '\u0301']), ('\u0156', &['\x52', '\u0327']),
+ ('\u0157', &['\x72', '\u0327']), ('\u0158', &['\x52', '\u030c']), ('\u0159', &['\x72',
+ '\u030c']), ('\u015a', &['\x53', '\u0301']), ('\u015b', &['\x73', '\u0301']), ('\u015c',
+ &['\x53', '\u0302']), ('\u015d', &['\x73', '\u0302']), ('\u015e', &['\x53', '\u0327']),
+ ('\u015f', &['\x73', '\u0327']), ('\u0160', &['\x53', '\u030c']), ('\u0161', &['\x73',
+ '\u030c']), ('\u0162', &['\x54', '\u0327']), ('\u0163', &['\x74', '\u0327']), ('\u0164',
+ &['\x54', '\u030c']), ('\u0165', &['\x74', '\u030c']), ('\u0168', &['\x55', '\u0303']),
+ ('\u0169', &['\x75', '\u0303']), ('\u016a', &['\x55', '\u0304']), ('\u016b', &['\x75',
+ '\u0304']), ('\u016c', &['\x55', '\u0306']), ('\u016d', &['\x75', '\u0306']), ('\u016e',
+ &['\x55', '\u030a']), ('\u016f', &['\x75', '\u030a']), ('\u0170', &['\x55', '\u030b']),
+ ('\u0171', &['\x75', '\u030b']), ('\u0172', &['\x55', '\u0328']), ('\u0173', &['\x75',
+ '\u0328']), ('\u0174', &['\x57', '\u0302']), ('\u0175', &['\x77', '\u0302']), ('\u0176',
+ &['\x59', '\u0302']), ('\u0177', &['\x79', '\u0302']), ('\u0178', &['\x59', '\u0308']),
+ ('\u0179', &['\x5a', '\u0301']), ('\u017a', &['\x7a', '\u0301']), ('\u017b', &['\x5a',
+ '\u0307']), ('\u017c', &['\x7a', '\u0307']), ('\u017d', &['\x5a', '\u030c']), ('\u017e',
+ &['\x7a', '\u030c']), ('\u01a0', &['\x4f', '\u031b']), ('\u01a1', &['\x6f', '\u031b']),
+ ('\u01af', &['\x55', '\u031b']), ('\u01b0', &['\x75', '\u031b']), ('\u01cd', &['\x41',
+ '\u030c']), ('\u01ce', &['\x61', '\u030c']), ('\u01cf', &['\x49', '\u030c']), ('\u01d0',
+ &['\x69', '\u030c']), ('\u01d1', &['\x4f', '\u030c']), ('\u01d2', &['\x6f', '\u030c']),
+ ('\u01d3', &['\x55', '\u030c']), ('\u01d4', &['\x75', '\u030c']), ('\u01d5', &['\xdc',
+ '\u0304']), ('\u01d6', &['\xfc', '\u0304']), ('\u01d7', &['\xdc', '\u0301']), ('\u01d8',
+ &['\xfc', '\u0301']), ('\u01d9', &['\xdc', '\u030c']), ('\u01da', &['\xfc', '\u030c']),
+ ('\u01db', &['\xdc', '\u0300']), ('\u01dc', &['\xfc', '\u0300']), ('\u01de', &['\xc4',
+ '\u0304']), ('\u01df', &['\xe4', '\u0304']), ('\u01e0', &['\u0226', '\u0304']), ('\u01e1',
+ &['\u0227', '\u0304']), ('\u01e2', &['\xc6', '\u0304']), ('\u01e3', &['\xe6', '\u0304']),
+ ('\u01e6', &['\x47', '\u030c']), ('\u01e7', &['\x67', '\u030c']), ('\u01e8', &['\x4b',
+ '\u030c']), ('\u01e9', &['\x6b', '\u030c']), ('\u01ea', &['\x4f', '\u0328']), ('\u01eb',
+ &['\x6f', '\u0328']), ('\u01ec', &['\u01ea', '\u0304']), ('\u01ed', &['\u01eb', '\u0304']),
+ ('\u01ee', &['\u01b7', '\u030c']), ('\u01ef', &['\u0292', '\u030c']), ('\u01f0', &['\x6a',
+ '\u030c']), ('\u01f4', &['\x47', '\u0301']), ('\u01f5', &['\x67', '\u0301']), ('\u01f8',
+ &['\x4e', '\u0300']), ('\u01f9', &['\x6e', '\u0300']), ('\u01fa', &['\xc5', '\u0301']),
+ ('\u01fb', &['\xe5', '\u0301']), ('\u01fc', &['\xc6', '\u0301']), ('\u01fd', &['\xe6',
+ '\u0301']), ('\u01fe', &['\xd8', '\u0301']), ('\u01ff', &['\xf8', '\u0301']), ('\u0200',
+ &['\x41', '\u030f']), ('\u0201', &['\x61', '\u030f']), ('\u0202', &['\x41', '\u0311']),
+ ('\u0203', &['\x61', '\u0311']), ('\u0204', &['\x45', '\u030f']), ('\u0205', &['\x65',
+ '\u030f']), ('\u0206', &['\x45', '\u0311']), ('\u0207', &['\x65', '\u0311']), ('\u0208',
+ &['\x49', '\u030f']), ('\u0209', &['\x69', '\u030f']), ('\u020a', &['\x49', '\u0311']),
+ ('\u020b', &['\x69', '\u0311']), ('\u020c', &['\x4f', '\u030f']), ('\u020d', &['\x6f',
+ '\u030f']), ('\u020e', &['\x4f', '\u0311']), ('\u020f', &['\x6f', '\u0311']), ('\u0210',
+ &['\x52', '\u030f']), ('\u0211', &['\x72', '\u030f']), ('\u0212', &['\x52', '\u0311']),
+ ('\u0213', &['\x72', '\u0311']), ('\u0214', &['\x55', '\u030f']), ('\u0215', &['\x75',
+ '\u030f']), ('\u0216', &['\x55', '\u0311']), ('\u0217', &['\x75', '\u0311']), ('\u0218',
+ &['\x53', '\u0326']), ('\u0219', &['\x73', '\u0326']), ('\u021a', &['\x54', '\u0326']),
+ ('\u021b', &['\x74', '\u0326']), ('\u021e', &['\x48', '\u030c']), ('\u021f', &['\x68',
+ '\u030c']), ('\u0226', &['\x41', '\u0307']), ('\u0227', &['\x61', '\u0307']), ('\u0228',
+ &['\x45', '\u0327']), ('\u0229', &['\x65', '\u0327']), ('\u022a', &['\xd6', '\u0304']),
+ ('\u022b', &['\xf6', '\u0304']), ('\u022c', &['\xd5', '\u0304']), ('\u022d', &['\xf5',
+ '\u0304']), ('\u022e', &['\x4f', '\u0307']), ('\u022f', &['\x6f', '\u0307']), ('\u0230',
+ &['\u022e', '\u0304']), ('\u0231', &['\u022f', '\u0304']), ('\u0232', &['\x59', '\u0304']),
+ ('\u0233', &['\x79', '\u0304']), ('\u0340', &['\u0300']), ('\u0341', &['\u0301']),
+ ('\u0343', &['\u0313']), ('\u0344', &['\u0308', '\u0301']), ('\u0374', &['\u02b9']),
+ ('\u037e', &['\x3b']), ('\u0385', &['\xa8', '\u0301']), ('\u0386', &['\u0391', '\u0301']),
+ ('\u0387', &['\xb7']), ('\u0388', &['\u0395', '\u0301']), ('\u0389', &['\u0397', '\u0301']),
+ ('\u038a', &['\u0399', '\u0301']), ('\u038c', &['\u039f', '\u0301']), ('\u038e', &['\u03a5',
+ '\u0301']), ('\u038f', &['\u03a9', '\u0301']), ('\u0390', &['\u03ca', '\u0301']), ('\u03aa',
+ &['\u0399', '\u0308']), ('\u03ab', &['\u03a5', '\u0308']), ('\u03ac', &['\u03b1',
+ '\u0301']), ('\u03ad', &['\u03b5', '\u0301']), ('\u03ae', &['\u03b7', '\u0301']), ('\u03af',
+ &['\u03b9', '\u0301']), ('\u03b0', &['\u03cb', '\u0301']), ('\u03ca', &['\u03b9',
+ '\u0308']), ('\u03cb', &['\u03c5', '\u0308']), ('\u03cc', &['\u03bf', '\u0301']), ('\u03cd',
+ &['\u03c5', '\u0301']), ('\u03ce', &['\u03c9', '\u0301']), ('\u03d3', &['\u03d2',
+ '\u0301']), ('\u03d4', &['\u03d2', '\u0308']), ('\u0400', &['\u0415', '\u0300']), ('\u0401',
+ &['\u0415', '\u0308']), ('\u0403', &['\u0413', '\u0301']), ('\u0407', &['\u0406',
+ '\u0308']), ('\u040c', &['\u041a', '\u0301']), ('\u040d', &['\u0418', '\u0300']), ('\u040e',
+ &['\u0423', '\u0306']), ('\u0419', &['\u0418', '\u0306']), ('\u0439', &['\u0438',
+ '\u0306']), ('\u0450', &['\u0435', '\u0300']), ('\u0451', &['\u0435', '\u0308']), ('\u0453',
+ &['\u0433', '\u0301']), ('\u0457', &['\u0456', '\u0308']), ('\u045c', &['\u043a',
+ '\u0301']), ('\u045d', &['\u0438', '\u0300']), ('\u045e', &['\u0443', '\u0306']), ('\u0476',
+ &['\u0474', '\u030f']), ('\u0477', &['\u0475', '\u030f']), ('\u04c1', &['\u0416',
+ '\u0306']), ('\u04c2', &['\u0436', '\u0306']), ('\u04d0', &['\u0410', '\u0306']), ('\u04d1',
+ &['\u0430', '\u0306']), ('\u04d2', &['\u0410', '\u0308']), ('\u04d3', &['\u0430',
+ '\u0308']), ('\u04d6', &['\u0415', '\u0306']), ('\u04d7', &['\u0435', '\u0306']), ('\u04da',
+ &['\u04d8', '\u0308']), ('\u04db', &['\u04d9', '\u0308']), ('\u04dc', &['\u0416',
+ '\u0308']), ('\u04dd', &['\u0436', '\u0308']), ('\u04de', &['\u0417', '\u0308']), ('\u04df',
+ &['\u0437', '\u0308']), ('\u04e2', &['\u0418', '\u0304']), ('\u04e3', &['\u0438',
+ '\u0304']), ('\u04e4', &['\u0418', '\u0308']), ('\u04e5', &['\u0438', '\u0308']), ('\u04e6',
+ &['\u041e', '\u0308']), ('\u04e7', &['\u043e', '\u0308']), ('\u04ea', &['\u04e8',
+ '\u0308']), ('\u04eb', &['\u04e9', '\u0308']), ('\u04ec', &['\u042d', '\u0308']), ('\u04ed',
+ &['\u044d', '\u0308']), ('\u04ee', &['\u0423', '\u0304']), ('\u04ef', &['\u0443',
+ '\u0304']), ('\u04f0', &['\u0423', '\u0308']), ('\u04f1', &['\u0443', '\u0308']), ('\u04f2',
+ &['\u0423', '\u030b']), ('\u04f3', &['\u0443', '\u030b']), ('\u04f4', &['\u0427',
+ '\u0308']), ('\u04f5', &['\u0447', '\u0308']), ('\u04f8', &['\u042b', '\u0308']), ('\u04f9',
+ &['\u044b', '\u0308']), ('\u0622', &['\u0627', '\u0653']), ('\u0623', &['\u0627',
+ '\u0654']), ('\u0624', &['\u0648', '\u0654']), ('\u0625', &['\u0627', '\u0655']), ('\u0626',
+ &['\u064a', '\u0654']), ('\u06c0', &['\u06d5', '\u0654']), ('\u06c2', &['\u06c1',
+ '\u0654']), ('\u06d3', &['\u06d2', '\u0654']), ('\u0929', &['\u0928', '\u093c']), ('\u0931',
+ &['\u0930', '\u093c']), ('\u0934', &['\u0933', '\u093c']), ('\u0958', &['\u0915',
+ '\u093c']), ('\u0959', &['\u0916', '\u093c']), ('\u095a', &['\u0917', '\u093c']), ('\u095b',
+ &['\u091c', '\u093c']), ('\u095c', &['\u0921', '\u093c']), ('\u095d', &['\u0922',
+ '\u093c']), ('\u095e', &['\u092b', '\u093c']), ('\u095f', &['\u092f', '\u093c']), ('\u09cb',
+ &['\u09c7', '\u09be']), ('\u09cc', &['\u09c7', '\u09d7']), ('\u09dc', &['\u09a1',
+ '\u09bc']), ('\u09dd', &['\u09a2', '\u09bc']), ('\u09df', &['\u09af', '\u09bc']), ('\u0a33',
+ &['\u0a32', '\u0a3c']), ('\u0a36', &['\u0a38', '\u0a3c']), ('\u0a59', &['\u0a16',
+ '\u0a3c']), ('\u0a5a', &['\u0a17', '\u0a3c']), ('\u0a5b', &['\u0a1c', '\u0a3c']), ('\u0a5e',
+ &['\u0a2b', '\u0a3c']), ('\u0b48', &['\u0b47', '\u0b56']), ('\u0b4b', &['\u0b47',
+ '\u0b3e']), ('\u0b4c', &['\u0b47', '\u0b57']), ('\u0b5c', &['\u0b21', '\u0b3c']), ('\u0b5d',
+ &['\u0b22', '\u0b3c']), ('\u0b94', &['\u0b92', '\u0bd7']), ('\u0bca', &['\u0bc6',
+ '\u0bbe']), ('\u0bcb', &['\u0bc7', '\u0bbe']), ('\u0bcc', &['\u0bc6', '\u0bd7']), ('\u0c48',
+ &['\u0c46', '\u0c56']), ('\u0cc0', &['\u0cbf', '\u0cd5']), ('\u0cc7', &['\u0cc6',
+ '\u0cd5']), ('\u0cc8', &['\u0cc6', '\u0cd6']), ('\u0cca', &['\u0cc6', '\u0cc2']), ('\u0ccb',
+ &['\u0cca', '\u0cd5']), ('\u0d4a', &['\u0d46', '\u0d3e']), ('\u0d4b', &['\u0d47',
+ '\u0d3e']), ('\u0d4c', &['\u0d46', '\u0d57']), ('\u0dda', &['\u0dd9', '\u0dca']), ('\u0ddc',
+ &['\u0dd9', '\u0dcf']), ('\u0ddd', &['\u0ddc', '\u0dca']), ('\u0dde', &['\u0dd9',
+ '\u0ddf']), ('\u0f43', &['\u0f42', '\u0fb7']), ('\u0f4d', &['\u0f4c', '\u0fb7']), ('\u0f52',
+ &['\u0f51', '\u0fb7']), ('\u0f57', &['\u0f56', '\u0fb7']), ('\u0f5c', &['\u0f5b',
+ '\u0fb7']), ('\u0f69', &['\u0f40', '\u0fb5']), ('\u0f73', &['\u0f71', '\u0f72']), ('\u0f75',
+ &['\u0f71', '\u0f74']), ('\u0f76', &['\u0fb2', '\u0f80']), ('\u0f78', &['\u0fb3',
+ '\u0f80']), ('\u0f81', &['\u0f71', '\u0f80']), ('\u0f93', &['\u0f92', '\u0fb7']), ('\u0f9d',
+ &['\u0f9c', '\u0fb7']), ('\u0fa2', &['\u0fa1', '\u0fb7']), ('\u0fa7', &['\u0fa6',
+ '\u0fb7']), ('\u0fac', &['\u0fab', '\u0fb7']), ('\u0fb9', &['\u0f90', '\u0fb5']), ('\u1026',
+ &['\u1025', '\u102e']), ('\u1b06', &['\u1b05', '\u1b35']), ('\u1b08', &['\u1b07',
+ '\u1b35']), ('\u1b0a', &['\u1b09', '\u1b35']), ('\u1b0c', &['\u1b0b', '\u1b35']), ('\u1b0e',
+ &['\u1b0d', '\u1b35']), ('\u1b12', &['\u1b11', '\u1b35']), ('\u1b3b', &['\u1b3a',
+ '\u1b35']), ('\u1b3d', &['\u1b3c', '\u1b35']), ('\u1b40', &['\u1b3e', '\u1b35']), ('\u1b41',
+ &['\u1b3f', '\u1b35']), ('\u1b43', &['\u1b42', '\u1b35']), ('\u1e00', &['\x41', '\u0325']),
+ ('\u1e01', &['\x61', '\u0325']), ('\u1e02', &['\x42', '\u0307']), ('\u1e03', &['\x62',
+ '\u0307']), ('\u1e04', &['\x42', '\u0323']), ('\u1e05', &['\x62', '\u0323']), ('\u1e06',
+ &['\x42', '\u0331']), ('\u1e07', &['\x62', '\u0331']), ('\u1e08', &['\xc7', '\u0301']),
+ ('\u1e09', &['\xe7', '\u0301']), ('\u1e0a', &['\x44', '\u0307']), ('\u1e0b', &['\x64',
+ '\u0307']), ('\u1e0c', &['\x44', '\u0323']), ('\u1e0d', &['\x64', '\u0323']), ('\u1e0e',
+ &['\x44', '\u0331']), ('\u1e0f', &['\x64', '\u0331']), ('\u1e10', &['\x44', '\u0327']),
+ ('\u1e11', &['\x64', '\u0327']), ('\u1e12', &['\x44', '\u032d']), ('\u1e13', &['\x64',
+ '\u032d']), ('\u1e14', &['\u0112', '\u0300']), ('\u1e15', &['\u0113', '\u0300']), ('\u1e16',
+ &['\u0112', '\u0301']), ('\u1e17', &['\u0113', '\u0301']), ('\u1e18', &['\x45', '\u032d']),
+ ('\u1e19', &['\x65', '\u032d']), ('\u1e1a', &['\x45', '\u0330']), ('\u1e1b', &['\x65',
+ '\u0330']), ('\u1e1c', &['\u0228', '\u0306']), ('\u1e1d', &['\u0229', '\u0306']), ('\u1e1e',
+ &['\x46', '\u0307']), ('\u1e1f', &['\x66', '\u0307']), ('\u1e20', &['\x47', '\u0304']),
+ ('\u1e21', &['\x67', '\u0304']), ('\u1e22', &['\x48', '\u0307']), ('\u1e23', &['\x68',
+ '\u0307']), ('\u1e24', &['\x48', '\u0323']), ('\u1e25', &['\x68', '\u0323']), ('\u1e26',
+ &['\x48', '\u0308']), ('\u1e27', &['\x68', '\u0308']), ('\u1e28', &['\x48', '\u0327']),
+ ('\u1e29', &['\x68', '\u0327']), ('\u1e2a', &['\x48', '\u032e']), ('\u1e2b', &['\x68',
+ '\u032e']), ('\u1e2c', &['\x49', '\u0330']), ('\u1e2d', &['\x69', '\u0330']), ('\u1e2e',
+ &['\xcf', '\u0301']), ('\u1e2f', &['\xef', '\u0301']), ('\u1e30', &['\x4b', '\u0301']),
+ ('\u1e31', &['\x6b', '\u0301']), ('\u1e32', &['\x4b', '\u0323']), ('\u1e33', &['\x6b',
+ '\u0323']), ('\u1e34', &['\x4b', '\u0331']), ('\u1e35', &['\x6b', '\u0331']), ('\u1e36',
+ &['\x4c', '\u0323']), ('\u1e37', &['\x6c', '\u0323']), ('\u1e38', &['\u1e36', '\u0304']),
+ ('\u1e39', &['\u1e37', '\u0304']), ('\u1e3a', &['\x4c', '\u0331']), ('\u1e3b', &['\x6c',
+ '\u0331']), ('\u1e3c', &['\x4c', '\u032d']), ('\u1e3d', &['\x6c', '\u032d']), ('\u1e3e',
+ &['\x4d', '\u0301']), ('\u1e3f', &['\x6d', '\u0301']), ('\u1e40', &['\x4d', '\u0307']),
+ ('\u1e41', &['\x6d', '\u0307']), ('\u1e42', &['\x4d', '\u0323']), ('\u1e43', &['\x6d',
+ '\u0323']), ('\u1e44', &['\x4e', '\u0307']), ('\u1e45', &['\x6e', '\u0307']), ('\u1e46',
+ &['\x4e', '\u0323']), ('\u1e47', &['\x6e', '\u0323']), ('\u1e48', &['\x4e', '\u0331']),
+ ('\u1e49', &['\x6e', '\u0331']), ('\u1e4a', &['\x4e', '\u032d']), ('\u1e4b', &['\x6e',
+ '\u032d']), ('\u1e4c', &['\xd5', '\u0301']), ('\u1e4d', &['\xf5', '\u0301']), ('\u1e4e',
+ &['\xd5', '\u0308']), ('\u1e4f', &['\xf5', '\u0308']), ('\u1e50', &['\u014c', '\u0300']),
+ ('\u1e51', &['\u014d', '\u0300']), ('\u1e52', &['\u014c', '\u0301']), ('\u1e53', &['\u014d',
+ '\u0301']), ('\u1e54', &['\x50', '\u0301']), ('\u1e55', &['\x70', '\u0301']), ('\u1e56',
+ &['\x50', '\u0307']), ('\u1e57', &['\x70', '\u0307']), ('\u1e58', &['\x52', '\u0307']),
+ ('\u1e59', &['\x72', '\u0307']), ('\u1e5a', &['\x52', '\u0323']), ('\u1e5b', &['\x72',
+ '\u0323']), ('\u1e5c', &['\u1e5a', '\u0304']), ('\u1e5d', &['\u1e5b', '\u0304']), ('\u1e5e',
+ &['\x52', '\u0331']), ('\u1e5f', &['\x72', '\u0331']), ('\u1e60', &['\x53', '\u0307']),
+ ('\u1e61', &['\x73', '\u0307']), ('\u1e62', &['\x53', '\u0323']), ('\u1e63', &['\x73',
+ '\u0323']), ('\u1e64', &['\u015a', '\u0307']), ('\u1e65', &['\u015b', '\u0307']), ('\u1e66',
+ &['\u0160', '\u0307']), ('\u1e67', &['\u0161', '\u0307']), ('\u1e68', &['\u1e62',
+ '\u0307']), ('\u1e69', &['\u1e63', '\u0307']), ('\u1e6a', &['\x54', '\u0307']), ('\u1e6b',
+ &['\x74', '\u0307']), ('\u1e6c', &['\x54', '\u0323']), ('\u1e6d', &['\x74', '\u0323']),
+ ('\u1e6e', &['\x54', '\u0331']), ('\u1e6f', &['\x74', '\u0331']), ('\u1e70', &['\x54',
+ '\u032d']), ('\u1e71', &['\x74', '\u032d']), ('\u1e72', &['\x55', '\u0324']), ('\u1e73',
+ &['\x75', '\u0324']), ('\u1e74', &['\x55', '\u0330']), ('\u1e75', &['\x75', '\u0330']),
+ ('\u1e76', &['\x55', '\u032d']), ('\u1e77', &['\x75', '\u032d']), ('\u1e78', &['\u0168',
+ '\u0301']), ('\u1e79', &['\u0169', '\u0301']), ('\u1e7a', &['\u016a', '\u0308']), ('\u1e7b',
+ &['\u016b', '\u0308']), ('\u1e7c', &['\x56', '\u0303']), ('\u1e7d', &['\x76', '\u0303']),
+ ('\u1e7e', &['\x56', '\u0323']), ('\u1e7f', &['\x76', '\u0323']), ('\u1e80', &['\x57',
+ '\u0300']), ('\u1e81', &['\x77', '\u0300']), ('\u1e82', &['\x57', '\u0301']), ('\u1e83',
+ &['\x77', '\u0301']), ('\u1e84', &['\x57', '\u0308']), ('\u1e85', &['\x77', '\u0308']),
+ ('\u1e86', &['\x57', '\u0307']), ('\u1e87', &['\x77', '\u0307']), ('\u1e88', &['\x57',
+ '\u0323']), ('\u1e89', &['\x77', '\u0323']), ('\u1e8a', &['\x58', '\u0307']), ('\u1e8b',
+ &['\x78', '\u0307']), ('\u1e8c', &['\x58', '\u0308']), ('\u1e8d', &['\x78', '\u0308']),
+ ('\u1e8e', &['\x59', '\u0307']), ('\u1e8f', &['\x79', '\u0307']), ('\u1e90', &['\x5a',
+ '\u0302']), ('\u1e91', &['\x7a', '\u0302']), ('\u1e92', &['\x5a', '\u0323']), ('\u1e93',
+ &['\x7a', '\u0323']), ('\u1e94', &['\x5a', '\u0331']), ('\u1e95', &['\x7a', '\u0331']),
+ ('\u1e96', &['\x68', '\u0331']), ('\u1e97', &['\x74', '\u0308']), ('\u1e98', &['\x77',
+ '\u030a']), ('\u1e99', &['\x79', '\u030a']), ('\u1e9b', &['\u017f', '\u0307']), ('\u1ea0',
+ &['\x41', '\u0323']), ('\u1ea1', &['\x61', '\u0323']), ('\u1ea2', &['\x41', '\u0309']),
+ ('\u1ea3', &['\x61', '\u0309']), ('\u1ea4', &['\xc2', '\u0301']), ('\u1ea5', &['\xe2',
+ '\u0301']), ('\u1ea6', &['\xc2', '\u0300']), ('\u1ea7', &['\xe2', '\u0300']), ('\u1ea8',
+ &['\xc2', '\u0309']), ('\u1ea9', &['\xe2', '\u0309']), ('\u1eaa', &['\xc2', '\u0303']),
+ ('\u1eab', &['\xe2', '\u0303']), ('\u1eac', &['\u1ea0', '\u0302']), ('\u1ead', &['\u1ea1',
+ '\u0302']), ('\u1eae', &['\u0102', '\u0301']), ('\u1eaf', &['\u0103', '\u0301']), ('\u1eb0',
+ &['\u0102', '\u0300']), ('\u1eb1', &['\u0103', '\u0300']), ('\u1eb2', &['\u0102',
+ '\u0309']), ('\u1eb3', &['\u0103', '\u0309']), ('\u1eb4', &['\u0102', '\u0303']), ('\u1eb5',
+ &['\u0103', '\u0303']), ('\u1eb6', &['\u1ea0', '\u0306']), ('\u1eb7', &['\u1ea1',
+ '\u0306']), ('\u1eb8', &['\x45', '\u0323']), ('\u1eb9', &['\x65', '\u0323']), ('\u1eba',
+ &['\x45', '\u0309']), ('\u1ebb', &['\x65', '\u0309']), ('\u1ebc', &['\x45', '\u0303']),
+ ('\u1ebd', &['\x65', '\u0303']), ('\u1ebe', &['\xca', '\u0301']), ('\u1ebf', &['\xea',
+ '\u0301']), ('\u1ec0', &['\xca', '\u0300']), ('\u1ec1', &['\xea', '\u0300']), ('\u1ec2',
+ &['\xca', '\u0309']), ('\u1ec3', &['\xea', '\u0309']), ('\u1ec4', &['\xca', '\u0303']),
+ ('\u1ec5', &['\xea', '\u0303']), ('\u1ec6', &['\u1eb8', '\u0302']), ('\u1ec7', &['\u1eb9',
+ '\u0302']), ('\u1ec8', &['\x49', '\u0309']), ('\u1ec9', &['\x69', '\u0309']), ('\u1eca',
+ &['\x49', '\u0323']), ('\u1ecb', &['\x69', '\u0323']), ('\u1ecc', &['\x4f', '\u0323']),
+ ('\u1ecd', &['\x6f', '\u0323']), ('\u1ece', &['\x4f', '\u0309']), ('\u1ecf', &['\x6f',
+ '\u0309']), ('\u1ed0', &['\xd4', '\u0301']), ('\u1ed1', &['\xf4', '\u0301']), ('\u1ed2',
+ &['\xd4', '\u0300']), ('\u1ed3', &['\xf4', '\u0300']), ('\u1ed4', &['\xd4', '\u0309']),
+ ('\u1ed5', &['\xf4', '\u0309']), ('\u1ed6', &['\xd4', '\u0303']), ('\u1ed7', &['\xf4',
+ '\u0303']), ('\u1ed8', &['\u1ecc', '\u0302']), ('\u1ed9', &['\u1ecd', '\u0302']), ('\u1eda',
+ &['\u01a0', '\u0301']), ('\u1edb', &['\u01a1', '\u0301']), ('\u1edc', &['\u01a0',
+ '\u0300']), ('\u1edd', &['\u01a1', '\u0300']), ('\u1ede', &['\u01a0', '\u0309']), ('\u1edf',
+ &['\u01a1', '\u0309']), ('\u1ee0', &['\u01a0', '\u0303']), ('\u1ee1', &['\u01a1',
+ '\u0303']), ('\u1ee2', &['\u01a0', '\u0323']), ('\u1ee3', &['\u01a1', '\u0323']), ('\u1ee4',
+ &['\x55', '\u0323']), ('\u1ee5', &['\x75', '\u0323']), ('\u1ee6', &['\x55', '\u0309']),
+ ('\u1ee7', &['\x75', '\u0309']), ('\u1ee8', &['\u01af', '\u0301']), ('\u1ee9', &['\u01b0',
+ '\u0301']), ('\u1eea', &['\u01af', '\u0300']), ('\u1eeb', &['\u01b0', '\u0300']), ('\u1eec',
+ &['\u01af', '\u0309']), ('\u1eed', &['\u01b0', '\u0309']), ('\u1eee', &['\u01af',
+ '\u0303']), ('\u1eef', &['\u01b0', '\u0303']), ('\u1ef0', &['\u01af', '\u0323']), ('\u1ef1',
+ &['\u01b0', '\u0323']), ('\u1ef2', &['\x59', '\u0300']), ('\u1ef3', &['\x79', '\u0300']),
+ ('\u1ef4', &['\x59', '\u0323']), ('\u1ef5', &['\x79', '\u0323']), ('\u1ef6', &['\x59',
+ '\u0309']), ('\u1ef7', &['\x79', '\u0309']), ('\u1ef8', &['\x59', '\u0303']), ('\u1ef9',
+ &['\x79', '\u0303']), ('\u1f00', &['\u03b1', '\u0313']), ('\u1f01', &['\u03b1', '\u0314']),
+ ('\u1f02', &['\u1f00', '\u0300']), ('\u1f03', &['\u1f01', '\u0300']), ('\u1f04', &['\u1f00',
+ '\u0301']), ('\u1f05', &['\u1f01', '\u0301']), ('\u1f06', &['\u1f00', '\u0342']), ('\u1f07',
+ &['\u1f01', '\u0342']), ('\u1f08', &['\u0391', '\u0313']), ('\u1f09', &['\u0391',
+ '\u0314']), ('\u1f0a', &['\u1f08', '\u0300']), ('\u1f0b', &['\u1f09', '\u0300']), ('\u1f0c',
+ &['\u1f08', '\u0301']), ('\u1f0d', &['\u1f09', '\u0301']), ('\u1f0e', &['\u1f08',
+ '\u0342']), ('\u1f0f', &['\u1f09', '\u0342']), ('\u1f10', &['\u03b5', '\u0313']), ('\u1f11',
+ &['\u03b5', '\u0314']), ('\u1f12', &['\u1f10', '\u0300']), ('\u1f13', &['\u1f11',
+ '\u0300']), ('\u1f14', &['\u1f10', '\u0301']), ('\u1f15', &['\u1f11', '\u0301']), ('\u1f18',
+ &['\u0395', '\u0313']), ('\u1f19', &['\u0395', '\u0314']), ('\u1f1a', &['\u1f18',
+ '\u0300']), ('\u1f1b', &['\u1f19', '\u0300']), ('\u1f1c', &['\u1f18', '\u0301']), ('\u1f1d',
+ &['\u1f19', '\u0301']), ('\u1f20', &['\u03b7', '\u0313']), ('\u1f21', &['\u03b7',
+ '\u0314']), ('\u1f22', &['\u1f20', '\u0300']), ('\u1f23', &['\u1f21', '\u0300']), ('\u1f24',
+ &['\u1f20', '\u0301']), ('\u1f25', &['\u1f21', '\u0301']), ('\u1f26', &['\u1f20',
+ '\u0342']), ('\u1f27', &['\u1f21', '\u0342']), ('\u1f28', &['\u0397', '\u0313']), ('\u1f29',
+ &['\u0397', '\u0314']), ('\u1f2a', &['\u1f28', '\u0300']), ('\u1f2b', &['\u1f29',
+ '\u0300']), ('\u1f2c', &['\u1f28', '\u0301']), ('\u1f2d', &['\u1f29', '\u0301']), ('\u1f2e',
+ &['\u1f28', '\u0342']), ('\u1f2f', &['\u1f29', '\u0342']), ('\u1f30', &['\u03b9',
+ '\u0313']), ('\u1f31', &['\u03b9', '\u0314']), ('\u1f32', &['\u1f30', '\u0300']), ('\u1f33',
+ &['\u1f31', '\u0300']), ('\u1f34', &['\u1f30', '\u0301']), ('\u1f35', &['\u1f31',
+ '\u0301']), ('\u1f36', &['\u1f30', '\u0342']), ('\u1f37', &['\u1f31', '\u0342']), ('\u1f38',
+ &['\u0399', '\u0313']), ('\u1f39', &['\u0399', '\u0314']), ('\u1f3a', &['\u1f38',
+ '\u0300']), ('\u1f3b', &['\u1f39', '\u0300']), ('\u1f3c', &['\u1f38', '\u0301']), ('\u1f3d',
+ &['\u1f39', '\u0301']), ('\u1f3e', &['\u1f38', '\u0342']), ('\u1f3f', &['\u1f39',
+ '\u0342']), ('\u1f40', &['\u03bf', '\u0313']), ('\u1f41', &['\u03bf', '\u0314']), ('\u1f42',
+ &['\u1f40', '\u0300']), ('\u1f43', &['\u1f41', '\u0300']), ('\u1f44', &['\u1f40',
+ '\u0301']), ('\u1f45', &['\u1f41', '\u0301']), ('\u1f48', &['\u039f', '\u0313']), ('\u1f49',
+ &['\u039f', '\u0314']), ('\u1f4a', &['\u1f48', '\u0300']), ('\u1f4b', &['\u1f49',
+ '\u0300']), ('\u1f4c', &['\u1f48', '\u0301']), ('\u1f4d', &['\u1f49', '\u0301']), ('\u1f50',
+ &['\u03c5', '\u0313']), ('\u1f51', &['\u03c5', '\u0314']), ('\u1f52', &['\u1f50',
+ '\u0300']), ('\u1f53', &['\u1f51', '\u0300']), ('\u1f54', &['\u1f50', '\u0301']), ('\u1f55',
+ &['\u1f51', '\u0301']), ('\u1f56', &['\u1f50', '\u0342']), ('\u1f57', &['\u1f51',
+ '\u0342']), ('\u1f59', &['\u03a5', '\u0314']), ('\u1f5b', &['\u1f59', '\u0300']), ('\u1f5d',
+ &['\u1f59', '\u0301']), ('\u1f5f', &['\u1f59', '\u0342']), ('\u1f60', &['\u03c9',
+ '\u0313']), ('\u1f61', &['\u03c9', '\u0314']), ('\u1f62', &['\u1f60', '\u0300']), ('\u1f63',
+ &['\u1f61', '\u0300']), ('\u1f64', &['\u1f60', '\u0301']), ('\u1f65', &['\u1f61',
+ '\u0301']), ('\u1f66', &['\u1f60', '\u0342']), ('\u1f67', &['\u1f61', '\u0342']), ('\u1f68',
+ &['\u03a9', '\u0313']), ('\u1f69', &['\u03a9', '\u0314']), ('\u1f6a', &['\u1f68',
+ '\u0300']), ('\u1f6b', &['\u1f69', '\u0300']), ('\u1f6c', &['\u1f68', '\u0301']), ('\u1f6d',
+ &['\u1f69', '\u0301']), ('\u1f6e', &['\u1f68', '\u0342']), ('\u1f6f', &['\u1f69',
+ '\u0342']), ('\u1f70', &['\u03b1', '\u0300']), ('\u1f71', &['\u03ac']), ('\u1f72',
+ &['\u03b5', '\u0300']), ('\u1f73', &['\u03ad']), ('\u1f74', &['\u03b7', '\u0300']),
+ ('\u1f75', &['\u03ae']), ('\u1f76', &['\u03b9', '\u0300']), ('\u1f77', &['\u03af']),
+ ('\u1f78', &['\u03bf', '\u0300']), ('\u1f79', &['\u03cc']), ('\u1f7a', &['\u03c5',
+ '\u0300']), ('\u1f7b', &['\u03cd']), ('\u1f7c', &['\u03c9', '\u0300']), ('\u1f7d',
+ &['\u03ce']), ('\u1f80', &['\u1f00', '\u0345']), ('\u1f81', &['\u1f01', '\u0345']),
+ ('\u1f82', &['\u1f02', '\u0345']), ('\u1f83', &['\u1f03', '\u0345']), ('\u1f84', &['\u1f04',
+ '\u0345']), ('\u1f85', &['\u1f05', '\u0345']), ('\u1f86', &['\u1f06', '\u0345']), ('\u1f87',
+ &['\u1f07', '\u0345']), ('\u1f88', &['\u1f08', '\u0345']), ('\u1f89', &['\u1f09',
+ '\u0345']), ('\u1f8a', &['\u1f0a', '\u0345']), ('\u1f8b', &['\u1f0b', '\u0345']), ('\u1f8c',
+ &['\u1f0c', '\u0345']), ('\u1f8d', &['\u1f0d', '\u0345']), ('\u1f8e', &['\u1f0e',
+ '\u0345']), ('\u1f8f', &['\u1f0f', '\u0345']), ('\u1f90', &['\u1f20', '\u0345']), ('\u1f91',
+ &['\u1f21', '\u0345']), ('\u1f92', &['\u1f22', '\u0345']), ('\u1f93', &['\u1f23',
+ '\u0345']), ('\u1f94', &['\u1f24', '\u0345']), ('\u1f95', &['\u1f25', '\u0345']), ('\u1f96',
+ &['\u1f26', '\u0345']), ('\u1f97', &['\u1f27', '\u0345']), ('\u1f98', &['\u1f28',
+ '\u0345']), ('\u1f99', &['\u1f29', '\u0345']), ('\u1f9a', &['\u1f2a', '\u0345']), ('\u1f9b',
+ &['\u1f2b', '\u0345']), ('\u1f9c', &['\u1f2c', '\u0345']), ('\u1f9d', &['\u1f2d',
+ '\u0345']), ('\u1f9e', &['\u1f2e', '\u0345']), ('\u1f9f', &['\u1f2f', '\u0345']), ('\u1fa0',
+ &['\u1f60', '\u0345']), ('\u1fa1', &['\u1f61', '\u0345']), ('\u1fa2', &['\u1f62',
+ '\u0345']), ('\u1fa3', &['\u1f63', '\u0345']), ('\u1fa4', &['\u1f64', '\u0345']), ('\u1fa5',
+ &['\u1f65', '\u0345']), ('\u1fa6', &['\u1f66', '\u0345']), ('\u1fa7', &['\u1f67',
+ '\u0345']), ('\u1fa8', &['\u1f68', '\u0345']), ('\u1fa9', &['\u1f69', '\u0345']), ('\u1faa',
+ &['\u1f6a', '\u0345']), ('\u1fab', &['\u1f6b', '\u0345']), ('\u1fac', &['\u1f6c',
+ '\u0345']), ('\u1fad', &['\u1f6d', '\u0345']), ('\u1fae', &['\u1f6e', '\u0345']), ('\u1faf',
+ &['\u1f6f', '\u0345']), ('\u1fb0', &['\u03b1', '\u0306']), ('\u1fb1', &['\u03b1',
+ '\u0304']), ('\u1fb2', &['\u1f70', '\u0345']), ('\u1fb3', &['\u03b1', '\u0345']), ('\u1fb4',
+ &['\u03ac', '\u0345']), ('\u1fb6', &['\u03b1', '\u0342']), ('\u1fb7', &['\u1fb6',
+ '\u0345']), ('\u1fb8', &['\u0391', '\u0306']), ('\u1fb9', &['\u0391', '\u0304']), ('\u1fba',
+ &['\u0391', '\u0300']), ('\u1fbb', &['\u0386']), ('\u1fbc', &['\u0391', '\u0345']),
+ ('\u1fbe', &['\u03b9']), ('\u1fc1', &['\xa8', '\u0342']), ('\u1fc2', &['\u1f74', '\u0345']),
+ ('\u1fc3', &['\u03b7', '\u0345']), ('\u1fc4', &['\u03ae', '\u0345']), ('\u1fc6', &['\u03b7',
+ '\u0342']), ('\u1fc7', &['\u1fc6', '\u0345']), ('\u1fc8', &['\u0395', '\u0300']), ('\u1fc9',
+ &['\u0388']), ('\u1fca', &['\u0397', '\u0300']), ('\u1fcb', &['\u0389']), ('\u1fcc',
+ &['\u0397', '\u0345']), ('\u1fcd', &['\u1fbf', '\u0300']), ('\u1fce', &['\u1fbf',
+ '\u0301']), ('\u1fcf', &['\u1fbf', '\u0342']), ('\u1fd0', &['\u03b9', '\u0306']), ('\u1fd1',
+ &['\u03b9', '\u0304']), ('\u1fd2', &['\u03ca', '\u0300']), ('\u1fd3', &['\u0390']),
+ ('\u1fd6', &['\u03b9', '\u0342']), ('\u1fd7', &['\u03ca', '\u0342']), ('\u1fd8', &['\u0399',
+ '\u0306']), ('\u1fd9', &['\u0399', '\u0304']), ('\u1fda', &['\u0399', '\u0300']), ('\u1fdb',
+ &['\u038a']), ('\u1fdd', &['\u1ffe', '\u0300']), ('\u1fde', &['\u1ffe', '\u0301']),
+ ('\u1fdf', &['\u1ffe', '\u0342']), ('\u1fe0', &['\u03c5', '\u0306']), ('\u1fe1', &['\u03c5',
+ '\u0304']), ('\u1fe2', &['\u03cb', '\u0300']), ('\u1fe3', &['\u03b0']), ('\u1fe4',
+ &['\u03c1', '\u0313']), ('\u1fe5', &['\u03c1', '\u0314']), ('\u1fe6', &['\u03c5',
+ '\u0342']), ('\u1fe7', &['\u03cb', '\u0342']), ('\u1fe8', &['\u03a5', '\u0306']), ('\u1fe9',
+ &['\u03a5', '\u0304']), ('\u1fea', &['\u03a5', '\u0300']), ('\u1feb', &['\u038e']),
+ ('\u1fec', &['\u03a1', '\u0314']), ('\u1fed', &['\xa8', '\u0300']), ('\u1fee', &['\u0385']),
+ ('\u1fef', &['\x60']), ('\u1ff2', &['\u1f7c', '\u0345']), ('\u1ff3', &['\u03c9', '\u0345']),
+ ('\u1ff4', &['\u03ce', '\u0345']), ('\u1ff6', &['\u03c9', '\u0342']), ('\u1ff7', &['\u1ff6',
+ '\u0345']), ('\u1ff8', &['\u039f', '\u0300']), ('\u1ff9', &['\u038c']), ('\u1ffa',
+ &['\u03a9', '\u0300']), ('\u1ffb', &['\u038f']), ('\u1ffc', &['\u03a9', '\u0345']),
+ ('\u1ffd', &['\xb4']), ('\u2000', &['\u2002']), ('\u2001', &['\u2003']), ('\u2126',
+ &['\u03a9']), ('\u212a', &['\x4b']), ('\u212b', &['\xc5']), ('\u219a', &['\u2190',
+ '\u0338']), ('\u219b', &['\u2192', '\u0338']), ('\u21ae', &['\u2194', '\u0338']), ('\u21cd',
+ &['\u21d0', '\u0338']), ('\u21ce', &['\u21d4', '\u0338']), ('\u21cf', &['\u21d2',
+ '\u0338']), ('\u2204', &['\u2203', '\u0338']), ('\u2209', &['\u2208', '\u0338']), ('\u220c',
+ &['\u220b', '\u0338']), ('\u2224', &['\u2223', '\u0338']), ('\u2226', &['\u2225',
+ '\u0338']), ('\u2241', &['\u223c', '\u0338']), ('\u2244', &['\u2243', '\u0338']), ('\u2247',
+ &['\u2245', '\u0338']), ('\u2249', &['\u2248', '\u0338']), ('\u2260', &['\x3d', '\u0338']),
+ ('\u2262', &['\u2261', '\u0338']), ('\u226d', &['\u224d', '\u0338']), ('\u226e', &['\x3c',
+ '\u0338']), ('\u226f', &['\x3e', '\u0338']), ('\u2270', &['\u2264', '\u0338']), ('\u2271',
+ &['\u2265', '\u0338']), ('\u2274', &['\u2272', '\u0338']), ('\u2275', &['\u2273',
+ '\u0338']), ('\u2278', &['\u2276', '\u0338']), ('\u2279', &['\u2277', '\u0338']), ('\u2280',
+ &['\u227a', '\u0338']), ('\u2281', &['\u227b', '\u0338']), ('\u2284', &['\u2282',
+ '\u0338']), ('\u2285', &['\u2283', '\u0338']), ('\u2288', &['\u2286', '\u0338']), ('\u2289',
+ &['\u2287', '\u0338']), ('\u22ac', &['\u22a2', '\u0338']), ('\u22ad', &['\u22a8',
+ '\u0338']), ('\u22ae', &['\u22a9', '\u0338']), ('\u22af', &['\u22ab', '\u0338']), ('\u22e0',
+ &['\u227c', '\u0338']), ('\u22e1', &['\u227d', '\u0338']), ('\u22e2', &['\u2291',
+ '\u0338']), ('\u22e3', &['\u2292', '\u0338']), ('\u22ea', &['\u22b2', '\u0338']), ('\u22eb',
+ &['\u22b3', '\u0338']), ('\u22ec', &['\u22b4', '\u0338']), ('\u22ed', &['\u22b5',
+ '\u0338']), ('\u2329', &['\u3008']), ('\u232a', &['\u3009']), ('\u2adc', &['\u2add',
+ '\u0338']), ('\u304c', &['\u304b', '\u3099']), ('\u304e', &['\u304d', '\u3099']), ('\u3050',
+ &['\u304f', '\u3099']), ('\u3052', &['\u3051', '\u3099']), ('\u3054', &['\u3053',
+ '\u3099']), ('\u3056', &['\u3055', '\u3099']), ('\u3058', &['\u3057', '\u3099']), ('\u305a',
+ &['\u3059', '\u3099']), ('\u305c', &['\u305b', '\u3099']), ('\u305e', &['\u305d',
+ '\u3099']), ('\u3060', &['\u305f', '\u3099']), ('\u3062', &['\u3061', '\u3099']), ('\u3065',
+ &['\u3064', '\u3099']), ('\u3067', &['\u3066', '\u3099']), ('\u3069', &['\u3068',
+ '\u3099']), ('\u3070', &['\u306f', '\u3099']), ('\u3071', &['\u306f', '\u309a']), ('\u3073',
+ &['\u3072', '\u3099']), ('\u3074', &['\u3072', '\u309a']), ('\u3076', &['\u3075',
+ '\u3099']), ('\u3077', &['\u3075', '\u309a']), ('\u3079', &['\u3078', '\u3099']), ('\u307a',
+ &['\u3078', '\u309a']), ('\u307c', &['\u307b', '\u3099']), ('\u307d', &['\u307b',
+ '\u309a']), ('\u3094', &['\u3046', '\u3099']), ('\u309e', &['\u309d', '\u3099']), ('\u30ac',
+ &['\u30ab', '\u3099']), ('\u30ae', &['\u30ad', '\u3099']), ('\u30b0', &['\u30af',
+ '\u3099']), ('\u30b2', &['\u30b1', '\u3099']), ('\u30b4', &['\u30b3', '\u3099']), ('\u30b6',
+ &['\u30b5', '\u3099']), ('\u30b8', &['\u30b7', '\u3099']), ('\u30ba', &['\u30b9',
+ '\u3099']), ('\u30bc', &['\u30bb', '\u3099']), ('\u30be', &['\u30bd', '\u3099']), ('\u30c0',
+ &['\u30bf', '\u3099']), ('\u30c2', &['\u30c1', '\u3099']), ('\u30c5', &['\u30c4',
+ '\u3099']), ('\u30c7', &['\u30c6', '\u3099']), ('\u30c9', &['\u30c8', '\u3099']), ('\u30d0',
+ &['\u30cf', '\u3099']), ('\u30d1', &['\u30cf', '\u309a']), ('\u30d3', &['\u30d2',
+ '\u3099']), ('\u30d4', &['\u30d2', '\u309a']), ('\u30d6', &['\u30d5', '\u3099']), ('\u30d7',
+ &['\u30d5', '\u309a']), ('\u30d9', &['\u30d8', '\u3099']), ('\u30da', &['\u30d8',
+ '\u309a']), ('\u30dc', &['\u30db', '\u3099']), ('\u30dd', &['\u30db', '\u309a']), ('\u30f4',
+ &['\u30a6', '\u3099']), ('\u30f7', &['\u30ef', '\u3099']), ('\u30f8', &['\u30f0',
+ '\u3099']), ('\u30f9', &['\u30f1', '\u3099']), ('\u30fa', &['\u30f2', '\u3099']), ('\u30fe',
+ &['\u30fd', '\u3099']), ('\uf900', &['\u8c48']), ('\uf901', &['\u66f4']), ('\uf902',
+ &['\u8eca']), ('\uf903', &['\u8cc8']), ('\uf904', &['\u6ed1']), ('\uf905', &['\u4e32']),
+ ('\uf906', &['\u53e5']), ('\uf907', &['\u9f9c']), ('\uf908', &['\u9f9c']), ('\uf909',
+ &['\u5951']), ('\uf90a', &['\u91d1']), ('\uf90b', &['\u5587']), ('\uf90c', &['\u5948']),
+ ('\uf90d', &['\u61f6']), ('\uf90e', &['\u7669']), ('\uf90f', &['\u7f85']), ('\uf910',
+ &['\u863f']), ('\uf911', &['\u87ba']), ('\uf912', &['\u88f8']), ('\uf913', &['\u908f']),
+ ('\uf914', &['\u6a02']), ('\uf915', &['\u6d1b']), ('\uf916', &['\u70d9']), ('\uf917',
+ &['\u73de']), ('\uf918', &['\u843d']), ('\uf919', &['\u916a']), ('\uf91a', &['\u99f1']),
+ ('\uf91b', &['\u4e82']), ('\uf91c', &['\u5375']), ('\uf91d', &['\u6b04']), ('\uf91e',
+ &['\u721b']), ('\uf91f', &['\u862d']), ('\uf920', &['\u9e1e']), ('\uf921', &['\u5d50']),
+ ('\uf922', &['\u6feb']), ('\uf923', &['\u85cd']), ('\uf924', &['\u8964']), ('\uf925',
+ &['\u62c9']), ('\uf926', &['\u81d8']), ('\uf927', &['\u881f']), ('\uf928', &['\u5eca']),
+ ('\uf929', &['\u6717']), ('\uf92a', &['\u6d6a']), ('\uf92b', &['\u72fc']), ('\uf92c',
+ &['\u90ce']), ('\uf92d', &['\u4f86']), ('\uf92e', &['\u51b7']), ('\uf92f', &['\u52de']),
+ ('\uf930', &['\u64c4']), ('\uf931', &['\u6ad3']), ('\uf932', &['\u7210']), ('\uf933',
+ &['\u76e7']), ('\uf934', &['\u8001']), ('\uf935', &['\u8606']), ('\uf936', &['\u865c']),
+ ('\uf937', &['\u8def']), ('\uf938', &['\u9732']), ('\uf939', &['\u9b6f']), ('\uf93a',
+ &['\u9dfa']), ('\uf93b', &['\u788c']), ('\uf93c', &['\u797f']), ('\uf93d', &['\u7da0']),
+ ('\uf93e', &['\u83c9']), ('\uf93f', &['\u9304']), ('\uf940', &['\u9e7f']), ('\uf941',
+ &['\u8ad6']), ('\uf942', &['\u58df']), ('\uf943', &['\u5f04']), ('\uf944', &['\u7c60']),
+ ('\uf945', &['\u807e']), ('\uf946', &['\u7262']), ('\uf947', &['\u78ca']), ('\uf948',
+ &['\u8cc2']), ('\uf949', &['\u96f7']), ('\uf94a', &['\u58d8']), ('\uf94b', &['\u5c62']),
+ ('\uf94c', &['\u6a13']), ('\uf94d', &['\u6dda']), ('\uf94e', &['\u6f0f']), ('\uf94f',
+ &['\u7d2f']), ('\uf950', &['\u7e37']), ('\uf951', &['\u964b']), ('\uf952', &['\u52d2']),
+ ('\uf953', &['\u808b']), ('\uf954', &['\u51dc']), ('\uf955', &['\u51cc']), ('\uf956',
+ &['\u7a1c']), ('\uf957', &['\u7dbe']), ('\uf958', &['\u83f1']), ('\uf959', &['\u9675']),
+ ('\uf95a', &['\u8b80']), ('\uf95b', &['\u62cf']), ('\uf95c', &['\u6a02']), ('\uf95d',
+ &['\u8afe']), ('\uf95e', &['\u4e39']), ('\uf95f', &['\u5be7']), ('\uf960', &['\u6012']),
+ ('\uf961', &['\u7387']), ('\uf962', &['\u7570']), ('\uf963', &['\u5317']), ('\uf964',
+ &['\u78fb']), ('\uf965', &['\u4fbf']), ('\uf966', &['\u5fa9']), ('\uf967', &['\u4e0d']),
+ ('\uf968', &['\u6ccc']), ('\uf969', &['\u6578']), ('\uf96a', &['\u7d22']), ('\uf96b',
+ &['\u53c3']), ('\uf96c', &['\u585e']), ('\uf96d', &['\u7701']), ('\uf96e', &['\u8449']),
+ ('\uf96f', &['\u8aaa']), ('\uf970', &['\u6bba']), ('\uf971', &['\u8fb0']), ('\uf972',
+ &['\u6c88']), ('\uf973', &['\u62fe']), ('\uf974', &['\u82e5']), ('\uf975', &['\u63a0']),
+ ('\uf976', &['\u7565']), ('\uf977', &['\u4eae']), ('\uf978', &['\u5169']), ('\uf979',
+ &['\u51c9']), ('\uf97a', &['\u6881']), ('\uf97b', &['\u7ce7']), ('\uf97c', &['\u826f']),
+ ('\uf97d', &['\u8ad2']), ('\uf97e', &['\u91cf']), ('\uf97f', &['\u52f5']), ('\uf980',
+ &['\u5442']), ('\uf981', &['\u5973']), ('\uf982', &['\u5eec']), ('\uf983', &['\u65c5']),
+ ('\uf984', &['\u6ffe']), ('\uf985', &['\u792a']), ('\uf986', &['\u95ad']), ('\uf987',
+ &['\u9a6a']), ('\uf988', &['\u9e97']), ('\uf989', &['\u9ece']), ('\uf98a', &['\u529b']),
+ ('\uf98b', &['\u66c6']), ('\uf98c', &['\u6b77']), ('\uf98d', &['\u8f62']), ('\uf98e',
+ &['\u5e74']), ('\uf98f', &['\u6190']), ('\uf990', &['\u6200']), ('\uf991', &['\u649a']),
+ ('\uf992', &['\u6f23']), ('\uf993', &['\u7149']), ('\uf994', &['\u7489']), ('\uf995',
+ &['\u79ca']), ('\uf996', &['\u7df4']), ('\uf997', &['\u806f']), ('\uf998', &['\u8f26']),
+ ('\uf999', &['\u84ee']), ('\uf99a', &['\u9023']), ('\uf99b', &['\u934a']), ('\uf99c',
+ &['\u5217']), ('\uf99d', &['\u52a3']), ('\uf99e', &['\u54bd']), ('\uf99f', &['\u70c8']),
+ ('\uf9a0', &['\u88c2']), ('\uf9a1', &['\u8aaa']), ('\uf9a2', &['\u5ec9']), ('\uf9a3',
+ &['\u5ff5']), ('\uf9a4', &['\u637b']), ('\uf9a5', &['\u6bae']), ('\uf9a6', &['\u7c3e']),
+ ('\uf9a7', &['\u7375']), ('\uf9a8', &['\u4ee4']), ('\uf9a9', &['\u56f9']), ('\uf9aa',
+ &['\u5be7']), ('\uf9ab', &['\u5dba']), ('\uf9ac', &['\u601c']), ('\uf9ad', &['\u73b2']),
+ ('\uf9ae', &['\u7469']), ('\uf9af', &['\u7f9a']), ('\uf9b0', &['\u8046']), ('\uf9b1',
+ &['\u9234']), ('\uf9b2', &['\u96f6']), ('\uf9b3', &['\u9748']), ('\uf9b4', &['\u9818']),
+ ('\uf9b5', &['\u4f8b']), ('\uf9b6', &['\u79ae']), ('\uf9b7', &['\u91b4']), ('\uf9b8',
+ &['\u96b8']), ('\uf9b9', &['\u60e1']), ('\uf9ba', &['\u4e86']), ('\uf9bb', &['\u50da']),
+ ('\uf9bc', &['\u5bee']), ('\uf9bd', &['\u5c3f']), ('\uf9be', &['\u6599']), ('\uf9bf',
+ &['\u6a02']), ('\uf9c0', &['\u71ce']), ('\uf9c1', &['\u7642']), ('\uf9c2', &['\u84fc']),
+ ('\uf9c3', &['\u907c']), ('\uf9c4', &['\u9f8d']), ('\uf9c5', &['\u6688']), ('\uf9c6',
+ &['\u962e']), ('\uf9c7', &['\u5289']), ('\uf9c8', &['\u677b']), ('\uf9c9', &['\u67f3']),
+ ('\uf9ca', &['\u6d41']), ('\uf9cb', &['\u6e9c']), ('\uf9cc', &['\u7409']), ('\uf9cd',
+ &['\u7559']), ('\uf9ce', &['\u786b']), ('\uf9cf', &['\u7d10']), ('\uf9d0', &['\u985e']),
+ ('\uf9d1', &['\u516d']), ('\uf9d2', &['\u622e']), ('\uf9d3', &['\u9678']), ('\uf9d4',
+ &['\u502b']), ('\uf9d5', &['\u5d19']), ('\uf9d6', &['\u6dea']), ('\uf9d7', &['\u8f2a']),
+ ('\uf9d8', &['\u5f8b']), ('\uf9d9', &['\u6144']), ('\uf9da', &['\u6817']), ('\uf9db',
+ &['\u7387']), ('\uf9dc', &['\u9686']), ('\uf9dd', &['\u5229']), ('\uf9de', &['\u540f']),
+ ('\uf9df', &['\u5c65']), ('\uf9e0', &['\u6613']), ('\uf9e1', &['\u674e']), ('\uf9e2',
+ &['\u68a8']), ('\uf9e3', &['\u6ce5']), ('\uf9e4', &['\u7406']), ('\uf9e5', &['\u75e2']),
+ ('\uf9e6', &['\u7f79']), ('\uf9e7', &['\u88cf']), ('\uf9e8', &['\u88e1']), ('\uf9e9',
+ &['\u91cc']), ('\uf9ea', &['\u96e2']), ('\uf9eb', &['\u533f']), ('\uf9ec', &['\u6eba']),
+ ('\uf9ed', &['\u541d']), ('\uf9ee', &['\u71d0']), ('\uf9ef', &['\u7498']), ('\uf9f0',
+ &['\u85fa']), ('\uf9f1', &['\u96a3']), ('\uf9f2', &['\u9c57']), ('\uf9f3', &['\u9e9f']),
+ ('\uf9f4', &['\u6797']), ('\uf9f5', &['\u6dcb']), ('\uf9f6', &['\u81e8']), ('\uf9f7',
+ &['\u7acb']), ('\uf9f8', &['\u7b20']), ('\uf9f9', &['\u7c92']), ('\uf9fa', &['\u72c0']),
+ ('\uf9fb', &['\u7099']), ('\uf9fc', &['\u8b58']), ('\uf9fd', &['\u4ec0']), ('\uf9fe',
+ &['\u8336']), ('\uf9ff', &['\u523a']), ('\ufa00', &['\u5207']), ('\ufa01', &['\u5ea6']),
+ ('\ufa02', &['\u62d3']), ('\ufa03', &['\u7cd6']), ('\ufa04', &['\u5b85']), ('\ufa05',
+ &['\u6d1e']), ('\ufa06', &['\u66b4']), ('\ufa07', &['\u8f3b']), ('\ufa08', &['\u884c']),
+ ('\ufa09', &['\u964d']), ('\ufa0a', &['\u898b']), ('\ufa0b', &['\u5ed3']), ('\ufa0c',
+ &['\u5140']), ('\ufa0d', &['\u55c0']), ('\ufa10', &['\u585a']), ('\ufa12', &['\u6674']),
+ ('\ufa15', &['\u51de']), ('\ufa16', &['\u732a']), ('\ufa17', &['\u76ca']), ('\ufa18',
+ &['\u793c']), ('\ufa19', &['\u795e']), ('\ufa1a', &['\u7965']), ('\ufa1b', &['\u798f']),
+ ('\ufa1c', &['\u9756']), ('\ufa1d', &['\u7cbe']), ('\ufa1e', &['\u7fbd']), ('\ufa20',
+ &['\u8612']), ('\ufa22', &['\u8af8']), ('\ufa25', &['\u9038']), ('\ufa26', &['\u90fd']),
+ ('\ufa2a', &['\u98ef']), ('\ufa2b', &['\u98fc']), ('\ufa2c', &['\u9928']), ('\ufa2d',
+ &['\u9db4']), ('\ufa2e', &['\u90de']), ('\ufa2f', &['\u96b7']), ('\ufa30', &['\u4fae']),
+ ('\ufa31', &['\u50e7']), ('\ufa32', &['\u514d']), ('\ufa33', &['\u52c9']), ('\ufa34',
+ &['\u52e4']), ('\ufa35', &['\u5351']), ('\ufa36', &['\u559d']), ('\ufa37', &['\u5606']),
+ ('\ufa38', &['\u5668']), ('\ufa39', &['\u5840']), ('\ufa3a', &['\u58a8']), ('\ufa3b',
+ &['\u5c64']), ('\ufa3c', &['\u5c6e']), ('\ufa3d', &['\u6094']), ('\ufa3e', &['\u6168']),
+ ('\ufa3f', &['\u618e']), ('\ufa40', &['\u61f2']), ('\ufa41', &['\u654f']), ('\ufa42',
+ &['\u65e2']), ('\ufa43', &['\u6691']), ('\ufa44', &['\u6885']), ('\ufa45', &['\u6d77']),
+ ('\ufa46', &['\u6e1a']), ('\ufa47', &['\u6f22']), ('\ufa48', &['\u716e']), ('\ufa49',
+ &['\u722b']), ('\ufa4a', &['\u7422']), ('\ufa4b', &['\u7891']), ('\ufa4c', &['\u793e']),
+ ('\ufa4d', &['\u7949']), ('\ufa4e', &['\u7948']), ('\ufa4f', &['\u7950']), ('\ufa50',
+ &['\u7956']), ('\ufa51', &['\u795d']), ('\ufa52', &['\u798d']), ('\ufa53', &['\u798e']),
+ ('\ufa54', &['\u7a40']), ('\ufa55', &['\u7a81']), ('\ufa56', &['\u7bc0']), ('\ufa57',
+ &['\u7df4']), ('\ufa58', &['\u7e09']), ('\ufa59', &['\u7e41']), ('\ufa5a', &['\u7f72']),
+ ('\ufa5b', &['\u8005']), ('\ufa5c', &['\u81ed']), ('\ufa5d', &['\u8279']), ('\ufa5e',
+ &['\u8279']), ('\ufa5f', &['\u8457']), ('\ufa60', &['\u8910']), ('\ufa61', &['\u8996']),
+ ('\ufa62', &['\u8b01']), ('\ufa63', &['\u8b39']), ('\ufa64', &['\u8cd3']), ('\ufa65',
+ &['\u8d08']), ('\ufa66', &['\u8fb6']), ('\ufa67', &['\u9038']), ('\ufa68', &['\u96e3']),
+ ('\ufa69', &['\u97ff']), ('\ufa6a', &['\u983b']), ('\ufa6b', &['\u6075']), ('\ufa6c',
+ &['\U000242ee']), ('\ufa6d', &['\u8218']), ('\ufa70', &['\u4e26']), ('\ufa71', &['\u51b5']),
+ ('\ufa72', &['\u5168']), ('\ufa73', &['\u4f80']), ('\ufa74', &['\u5145']), ('\ufa75',
+ &['\u5180']), ('\ufa76', &['\u52c7']), ('\ufa77', &['\u52fa']), ('\ufa78', &['\u559d']),
+ ('\ufa79', &['\u5555']), ('\ufa7a', &['\u5599']), ('\ufa7b', &['\u55e2']), ('\ufa7c',
+ &['\u585a']), ('\ufa7d', &['\u58b3']), ('\ufa7e', &['\u5944']), ('\ufa7f', &['\u5954']),
+ ('\ufa80', &['\u5a62']), ('\ufa81', &['\u5b28']), ('\ufa82', &['\u5ed2']), ('\ufa83',
+ &['\u5ed9']), ('\ufa84', &['\u5f69']), ('\ufa85', &['\u5fad']), ('\ufa86', &['\u60d8']),
+ ('\ufa87', &['\u614e']), ('\ufa88', &['\u6108']), ('\ufa89', &['\u618e']), ('\ufa8a',
+ &['\u6160']), ('\ufa8b', &['\u61f2']), ('\ufa8c', &['\u6234']), ('\ufa8d', &['\u63c4']),
+ ('\ufa8e', &['\u641c']), ('\ufa8f', &['\u6452']), ('\ufa90', &['\u6556']), ('\ufa91',
+ &['\u6674']), ('\ufa92', &['\u6717']), ('\ufa93', &['\u671b']), ('\ufa94', &['\u6756']),
+ ('\ufa95', &['\u6b79']), ('\ufa96', &['\u6bba']), ('\ufa97', &['\u6d41']), ('\ufa98',
+ &['\u6edb']), ('\ufa99', &['\u6ecb']), ('\ufa9a', &['\u6f22']), ('\ufa9b', &['\u701e']),
+ ('\ufa9c', &['\u716e']), ('\ufa9d', &['\u77a7']), ('\ufa9e', &['\u7235']), ('\ufa9f',
+ &['\u72af']), ('\ufaa0', &['\u732a']), ('\ufaa1', &['\u7471']), ('\ufaa2', &['\u7506']),
+ ('\ufaa3', &['\u753b']), ('\ufaa4', &['\u761d']), ('\ufaa5', &['\u761f']), ('\ufaa6',
+ &['\u76ca']), ('\ufaa7', &['\u76db']), ('\ufaa8', &['\u76f4']), ('\ufaa9', &['\u774a']),
+ ('\ufaaa', &['\u7740']), ('\ufaab', &['\u78cc']), ('\ufaac', &['\u7ab1']), ('\ufaad',
+ &['\u7bc0']), ('\ufaae', &['\u7c7b']), ('\ufaaf', &['\u7d5b']), ('\ufab0', &['\u7df4']),
+ ('\ufab1', &['\u7f3e']), ('\ufab2', &['\u8005']), ('\ufab3', &['\u8352']), ('\ufab4',
+ &['\u83ef']), ('\ufab5', &['\u8779']), ('\ufab6', &['\u8941']), ('\ufab7', &['\u8986']),
+ ('\ufab8', &['\u8996']), ('\ufab9', &['\u8abf']), ('\ufaba', &['\u8af8']), ('\ufabb',
+ &['\u8acb']), ('\ufabc', &['\u8b01']), ('\ufabd', &['\u8afe']), ('\ufabe', &['\u8aed']),
+ ('\ufabf', &['\u8b39']), ('\ufac0', &['\u8b8a']), ('\ufac1', &['\u8d08']), ('\ufac2',
+ &['\u8f38']), ('\ufac3', &['\u9072']), ('\ufac4', &['\u9199']), ('\ufac5', &['\u9276']),
+ ('\ufac6', &['\u967c']), ('\ufac7', &['\u96e3']), ('\ufac8', &['\u9756']), ('\ufac9',
+ &['\u97db']), ('\ufaca', &['\u97ff']), ('\ufacb', &['\u980b']), ('\ufacc', &['\u983b']),
+ ('\ufacd', &['\u9b12']), ('\uface', &['\u9f9c']), ('\ufacf', &['\U0002284a']), ('\ufad0',
+ &['\U00022844']), ('\ufad1', &['\U000233d5']), ('\ufad2', &['\u3b9d']), ('\ufad3',
+ &['\u4018']), ('\ufad4', &['\u4039']), ('\ufad5', &['\U00025249']), ('\ufad6',
+ &['\U00025cd0']), ('\ufad7', &['\U00027ed3']), ('\ufad8', &['\u9f43']), ('\ufad9',
+ &['\u9f8e']), ('\ufb1d', &['\u05d9', '\u05b4']), ('\ufb1f', &['\u05f2', '\u05b7']),
+ ('\ufb2a', &['\u05e9', '\u05c1']), ('\ufb2b', &['\u05e9', '\u05c2']), ('\ufb2c', &['\ufb49',
+ '\u05c1']), ('\ufb2d', &['\ufb49', '\u05c2']), ('\ufb2e', &['\u05d0', '\u05b7']), ('\ufb2f',
+ &['\u05d0', '\u05b8']), ('\ufb30', &['\u05d0', '\u05bc']), ('\ufb31', &['\u05d1',
+ '\u05bc']), ('\ufb32', &['\u05d2', '\u05bc']), ('\ufb33', &['\u05d3', '\u05bc']), ('\ufb34',
+ &['\u05d4', '\u05bc']), ('\ufb35', &['\u05d5', '\u05bc']), ('\ufb36', &['\u05d6',
+ '\u05bc']), ('\ufb38', &['\u05d8', '\u05bc']), ('\ufb39', &['\u05d9', '\u05bc']), ('\ufb3a',
+ &['\u05da', '\u05bc']), ('\ufb3b', &['\u05db', '\u05bc']), ('\ufb3c', &['\u05dc',
+ '\u05bc']), ('\ufb3e', &['\u05de', '\u05bc']), ('\ufb40', &['\u05e0', '\u05bc']), ('\ufb41',
+ &['\u05e1', '\u05bc']), ('\ufb43', &['\u05e3', '\u05bc']), ('\ufb44', &['\u05e4',
+ '\u05bc']), ('\ufb46', &['\u05e6', '\u05bc']), ('\ufb47', &['\u05e7', '\u05bc']), ('\ufb48',
+ &['\u05e8', '\u05bc']), ('\ufb49', &['\u05e9', '\u05bc']), ('\ufb4a', &['\u05ea',
+ '\u05bc']), ('\ufb4b', &['\u05d5', '\u05b9']), ('\ufb4c', &['\u05d1', '\u05bf']), ('\ufb4d',
+ &['\u05db', '\u05bf']), ('\ufb4e', &['\u05e4', '\u05bf']), ('\U0001109a', &['\U00011099',
+ '\U000110ba']), ('\U0001109c', &['\U0001109b', '\U000110ba']), ('\U000110ab',
+ &['\U000110a5', '\U000110ba']), ('\U0001112e', &['\U00011131', '\U00011127']),
+ ('\U0001112f', &['\U00011132', '\U00011127']), ('\U0001134b', &['\U00011347',
+ '\U0001133e']), ('\U0001134c', &['\U00011347', '\U00011357']), ('\U000114bb',
+ &['\U000114b9', '\U000114ba']), ('\U000114bc', &['\U000114b9', '\U000114b0']),
+ ('\U000114be', &['\U000114b9', '\U000114bd']), ('\U000115ba', &['\U000115b8',
+ '\U000115af']), ('\U000115bb', &['\U000115b9', '\U000115af']), ('\U0001d15e',
+ &['\U0001d157', '\U0001d165']), ('\U0001d15f', &['\U0001d158', '\U0001d165']),
+ ('\U0001d160', &['\U0001d15f', '\U0001d16e']), ('\U0001d161', &['\U0001d15f',
+ '\U0001d16f']), ('\U0001d162', &['\U0001d15f', '\U0001d170']), ('\U0001d163',
+ &['\U0001d15f', '\U0001d171']), ('\U0001d164', &['\U0001d15f', '\U0001d172']),
+ ('\U0001d1bb', &['\U0001d1b9', '\U0001d165']), ('\U0001d1bc', &['\U0001d1ba',
+ '\U0001d165']), ('\U0001d1bd', &['\U0001d1bb', '\U0001d16e']), ('\U0001d1be',
+ &['\U0001d1bc', '\U0001d16e']), ('\U0001d1bf', &['\U0001d1bb', '\U0001d16f']),
+ ('\U0001d1c0', &['\U0001d1bc', '\U0001d16f']), ('\U0002f800', &['\u4e3d']), ('\U0002f801',
+ &['\u4e38']), ('\U0002f802', &['\u4e41']), ('\U0002f803', &['\U00020122']), ('\U0002f804',
+ &['\u4f60']), ('\U0002f805', &['\u4fae']), ('\U0002f806', &['\u4fbb']), ('\U0002f807',
+ &['\u5002']), ('\U0002f808', &['\u507a']), ('\U0002f809', &['\u5099']), ('\U0002f80a',
+ &['\u50e7']), ('\U0002f80b', &['\u50cf']), ('\U0002f80c', &['\u349e']), ('\U0002f80d',
+ &['\U0002063a']), ('\U0002f80e', &['\u514d']), ('\U0002f80f', &['\u5154']), ('\U0002f810',
+ &['\u5164']), ('\U0002f811', &['\u5177']), ('\U0002f812', &['\U0002051c']), ('\U0002f813',
+ &['\u34b9']), ('\U0002f814', &['\u5167']), ('\U0002f815', &['\u518d']), ('\U0002f816',
+ &['\U0002054b']), ('\U0002f817', &['\u5197']), ('\U0002f818', &['\u51a4']), ('\U0002f819',
+ &['\u4ecc']), ('\U0002f81a', &['\u51ac']), ('\U0002f81b', &['\u51b5']), ('\U0002f81c',
+ &['\U000291df']), ('\U0002f81d', &['\u51f5']), ('\U0002f81e', &['\u5203']), ('\U0002f81f',
+ &['\u34df']), ('\U0002f820', &['\u523b']), ('\U0002f821', &['\u5246']), ('\U0002f822',
+ &['\u5272']), ('\U0002f823', &['\u5277']), ('\U0002f824', &['\u3515']), ('\U0002f825',
+ &['\u52c7']), ('\U0002f826', &['\u52c9']), ('\U0002f827', &['\u52e4']), ('\U0002f828',
+ &['\u52fa']), ('\U0002f829', &['\u5305']), ('\U0002f82a', &['\u5306']), ('\U0002f82b',
+ &['\u5317']), ('\U0002f82c', &['\u5349']), ('\U0002f82d', &['\u5351']), ('\U0002f82e',
+ &['\u535a']), ('\U0002f82f', &['\u5373']), ('\U0002f830', &['\u537d']), ('\U0002f831',
+ &['\u537f']), ('\U0002f832', &['\u537f']), ('\U0002f833', &['\u537f']), ('\U0002f834',
+ &['\U00020a2c']), ('\U0002f835', &['\u7070']), ('\U0002f836', &['\u53ca']), ('\U0002f837',
+ &['\u53df']), ('\U0002f838', &['\U00020b63']), ('\U0002f839', &['\u53eb']), ('\U0002f83a',
+ &['\u53f1']), ('\U0002f83b', &['\u5406']), ('\U0002f83c', &['\u549e']), ('\U0002f83d',
+ &['\u5438']), ('\U0002f83e', &['\u5448']), ('\U0002f83f', &['\u5468']), ('\U0002f840',
+ &['\u54a2']), ('\U0002f841', &['\u54f6']), ('\U0002f842', &['\u5510']), ('\U0002f843',
+ &['\u5553']), ('\U0002f844', &['\u5563']), ('\U0002f845', &['\u5584']), ('\U0002f846',
+ &['\u5584']), ('\U0002f847', &['\u5599']), ('\U0002f848', &['\u55ab']), ('\U0002f849',
+ &['\u55b3']), ('\U0002f84a', &['\u55c2']), ('\U0002f84b', &['\u5716']), ('\U0002f84c',
+ &['\u5606']), ('\U0002f84d', &['\u5717']), ('\U0002f84e', &['\u5651']), ('\U0002f84f',
+ &['\u5674']), ('\U0002f850', &['\u5207']), ('\U0002f851', &['\u58ee']), ('\U0002f852',
+ &['\u57ce']), ('\U0002f853', &['\u57f4']), ('\U0002f854', &['\u580d']), ('\U0002f855',
+ &['\u578b']), ('\U0002f856', &['\u5832']), ('\U0002f857', &['\u5831']), ('\U0002f858',
+ &['\u58ac']), ('\U0002f859', &['\U000214e4']), ('\U0002f85a', &['\u58f2']), ('\U0002f85b',
+ &['\u58f7']), ('\U0002f85c', &['\u5906']), ('\U0002f85d', &['\u591a']), ('\U0002f85e',
+ &['\u5922']), ('\U0002f85f', &['\u5962']), ('\U0002f860', &['\U000216a8']), ('\U0002f861',
+ &['\U000216ea']), ('\U0002f862', &['\u59ec']), ('\U0002f863', &['\u5a1b']), ('\U0002f864',
+ &['\u5a27']), ('\U0002f865', &['\u59d8']), ('\U0002f866', &['\u5a66']), ('\U0002f867',
+ &['\u36ee']), ('\U0002f868', &['\u36fc']), ('\U0002f869', &['\u5b08']), ('\U0002f86a',
+ &['\u5b3e']), ('\U0002f86b', &['\u5b3e']), ('\U0002f86c', &['\U000219c8']), ('\U0002f86d',
+ &['\u5bc3']), ('\U0002f86e', &['\u5bd8']), ('\U0002f86f', &['\u5be7']), ('\U0002f870',
+ &['\u5bf3']), ('\U0002f871', &['\U00021b18']), ('\U0002f872', &['\u5bff']), ('\U0002f873',
+ &['\u5c06']), ('\U0002f874', &['\u5f53']), ('\U0002f875', &['\u5c22']), ('\U0002f876',
+ &['\u3781']), ('\U0002f877', &['\u5c60']), ('\U0002f878', &['\u5c6e']), ('\U0002f879',
+ &['\u5cc0']), ('\U0002f87a', &['\u5c8d']), ('\U0002f87b', &['\U00021de4']), ('\U0002f87c',
+ &['\u5d43']), ('\U0002f87d', &['\U00021de6']), ('\U0002f87e', &['\u5d6e']), ('\U0002f87f',
+ &['\u5d6b']), ('\U0002f880', &['\u5d7c']), ('\U0002f881', &['\u5de1']), ('\U0002f882',
+ &['\u5de2']), ('\U0002f883', &['\u382f']), ('\U0002f884', &['\u5dfd']), ('\U0002f885',
+ &['\u5e28']), ('\U0002f886', &['\u5e3d']), ('\U0002f887', &['\u5e69']), ('\U0002f888',
+ &['\u3862']), ('\U0002f889', &['\U00022183']), ('\U0002f88a', &['\u387c']), ('\U0002f88b',
+ &['\u5eb0']), ('\U0002f88c', &['\u5eb3']), ('\U0002f88d', &['\u5eb6']), ('\U0002f88e',
+ &['\u5eca']), ('\U0002f88f', &['\U0002a392']), ('\U0002f890', &['\u5efe']), ('\U0002f891',
+ &['\U00022331']), ('\U0002f892', &['\U00022331']), ('\U0002f893', &['\u8201']),
+ ('\U0002f894', &['\u5f22']), ('\U0002f895', &['\u5f22']), ('\U0002f896', &['\u38c7']),
+ ('\U0002f897', &['\U000232b8']), ('\U0002f898', &['\U000261da']), ('\U0002f899',
+ &['\u5f62']), ('\U0002f89a', &['\u5f6b']), ('\U0002f89b', &['\u38e3']), ('\U0002f89c',
+ &['\u5f9a']), ('\U0002f89d', &['\u5fcd']), ('\U0002f89e', &['\u5fd7']), ('\U0002f89f',
+ &['\u5ff9']), ('\U0002f8a0', &['\u6081']), ('\U0002f8a1', &['\u393a']), ('\U0002f8a2',
+ &['\u391c']), ('\U0002f8a3', &['\u6094']), ('\U0002f8a4', &['\U000226d4']), ('\U0002f8a5',
+ &['\u60c7']), ('\U0002f8a6', &['\u6148']), ('\U0002f8a7', &['\u614c']), ('\U0002f8a8',
+ &['\u614e']), ('\U0002f8a9', &['\u614c']), ('\U0002f8aa', &['\u617a']), ('\U0002f8ab',
+ &['\u618e']), ('\U0002f8ac', &['\u61b2']), ('\U0002f8ad', &['\u61a4']), ('\U0002f8ae',
+ &['\u61af']), ('\U0002f8af', &['\u61de']), ('\U0002f8b0', &['\u61f2']), ('\U0002f8b1',
+ &['\u61f6']), ('\U0002f8b2', &['\u6210']), ('\U0002f8b3', &['\u621b']), ('\U0002f8b4',
+ &['\u625d']), ('\U0002f8b5', &['\u62b1']), ('\U0002f8b6', &['\u62d4']), ('\U0002f8b7',
+ &['\u6350']), ('\U0002f8b8', &['\U00022b0c']), ('\U0002f8b9', &['\u633d']), ('\U0002f8ba',
+ &['\u62fc']), ('\U0002f8bb', &['\u6368']), ('\U0002f8bc', &['\u6383']), ('\U0002f8bd',
+ &['\u63e4']), ('\U0002f8be', &['\U00022bf1']), ('\U0002f8bf', &['\u6422']), ('\U0002f8c0',
+ &['\u63c5']), ('\U0002f8c1', &['\u63a9']), ('\U0002f8c2', &['\u3a2e']), ('\U0002f8c3',
+ &['\u6469']), ('\U0002f8c4', &['\u647e']), ('\U0002f8c5', &['\u649d']), ('\U0002f8c6',
+ &['\u6477']), ('\U0002f8c7', &['\u3a6c']), ('\U0002f8c8', &['\u654f']), ('\U0002f8c9',
+ &['\u656c']), ('\U0002f8ca', &['\U0002300a']), ('\U0002f8cb', &['\u65e3']), ('\U0002f8cc',
+ &['\u66f8']), ('\U0002f8cd', &['\u6649']), ('\U0002f8ce', &['\u3b19']), ('\U0002f8cf',
+ &['\u6691']), ('\U0002f8d0', &['\u3b08']), ('\U0002f8d1', &['\u3ae4']), ('\U0002f8d2',
+ &['\u5192']), ('\U0002f8d3', &['\u5195']), ('\U0002f8d4', &['\u6700']), ('\U0002f8d5',
+ &['\u669c']), ('\U0002f8d6', &['\u80ad']), ('\U0002f8d7', &['\u43d9']), ('\U0002f8d8',
+ &['\u6717']), ('\U0002f8d9', &['\u671b']), ('\U0002f8da', &['\u6721']), ('\U0002f8db',
+ &['\u675e']), ('\U0002f8dc', &['\u6753']), ('\U0002f8dd', &['\U000233c3']), ('\U0002f8de',
+ &['\u3b49']), ('\U0002f8df', &['\u67fa']), ('\U0002f8e0', &['\u6785']), ('\U0002f8e1',
+ &['\u6852']), ('\U0002f8e2', &['\u6885']), ('\U0002f8e3', &['\U0002346d']), ('\U0002f8e4',
+ &['\u688e']), ('\U0002f8e5', &['\u681f']), ('\U0002f8e6', &['\u6914']), ('\U0002f8e7',
+ &['\u3b9d']), ('\U0002f8e8', &['\u6942']), ('\U0002f8e9', &['\u69a3']), ('\U0002f8ea',
+ &['\u69ea']), ('\U0002f8eb', &['\u6aa8']), ('\U0002f8ec', &['\U000236a3']), ('\U0002f8ed',
+ &['\u6adb']), ('\U0002f8ee', &['\u3c18']), ('\U0002f8ef', &['\u6b21']), ('\U0002f8f0',
+ &['\U000238a7']), ('\U0002f8f1', &['\u6b54']), ('\U0002f8f2', &['\u3c4e']), ('\U0002f8f3',
+ &['\u6b72']), ('\U0002f8f4', &['\u6b9f']), ('\U0002f8f5', &['\u6bba']), ('\U0002f8f6',
+ &['\u6bbb']), ('\U0002f8f7', &['\U00023a8d']), ('\U0002f8f8', &['\U00021d0b']),
+ ('\U0002f8f9', &['\U00023afa']), ('\U0002f8fa', &['\u6c4e']), ('\U0002f8fb',
+ &['\U00023cbc']), ('\U0002f8fc', &['\u6cbf']), ('\U0002f8fd', &['\u6ccd']), ('\U0002f8fe',
+ &['\u6c67']), ('\U0002f8ff', &['\u6d16']), ('\U0002f900', &['\u6d3e']), ('\U0002f901',
+ &['\u6d77']), ('\U0002f902', &['\u6d41']), ('\U0002f903', &['\u6d69']), ('\U0002f904',
+ &['\u6d78']), ('\U0002f905', &['\u6d85']), ('\U0002f906', &['\U00023d1e']), ('\U0002f907',
+ &['\u6d34']), ('\U0002f908', &['\u6e2f']), ('\U0002f909', &['\u6e6e']), ('\U0002f90a',
+ &['\u3d33']), ('\U0002f90b', &['\u6ecb']), ('\U0002f90c', &['\u6ec7']), ('\U0002f90d',
+ &['\U00023ed1']), ('\U0002f90e', &['\u6df9']), ('\U0002f90f', &['\u6f6e']), ('\U0002f910',
+ &['\U00023f5e']), ('\U0002f911', &['\U00023f8e']), ('\U0002f912', &['\u6fc6']),
+ ('\U0002f913', &['\u7039']), ('\U0002f914', &['\u701e']), ('\U0002f915', &['\u701b']),
+ ('\U0002f916', &['\u3d96']), ('\U0002f917', &['\u704a']), ('\U0002f918', &['\u707d']),
+ ('\U0002f919', &['\u7077']), ('\U0002f91a', &['\u70ad']), ('\U0002f91b', &['\U00020525']),
+ ('\U0002f91c', &['\u7145']), ('\U0002f91d', &['\U00024263']), ('\U0002f91e', &['\u719c']),
+ ('\U0002f91f', &['\U000243ab']), ('\U0002f920', &['\u7228']), ('\U0002f921', &['\u7235']),
+ ('\U0002f922', &['\u7250']), ('\U0002f923', &['\U00024608']), ('\U0002f924', &['\u7280']),
+ ('\U0002f925', &['\u7295']), ('\U0002f926', &['\U00024735']), ('\U0002f927',
+ &['\U00024814']), ('\U0002f928', &['\u737a']), ('\U0002f929', &['\u738b']), ('\U0002f92a',
+ &['\u3eac']), ('\U0002f92b', &['\u73a5']), ('\U0002f92c', &['\u3eb8']), ('\U0002f92d',
+ &['\u3eb8']), ('\U0002f92e', &['\u7447']), ('\U0002f92f', &['\u745c']), ('\U0002f930',
+ &['\u7471']), ('\U0002f931', &['\u7485']), ('\U0002f932', &['\u74ca']), ('\U0002f933',
+ &['\u3f1b']), ('\U0002f934', &['\u7524']), ('\U0002f935', &['\U00024c36']), ('\U0002f936',
+ &['\u753e']), ('\U0002f937', &['\U00024c92']), ('\U0002f938', &['\u7570']), ('\U0002f939',
+ &['\U0002219f']), ('\U0002f93a', &['\u7610']), ('\U0002f93b', &['\U00024fa1']),
+ ('\U0002f93c', &['\U00024fb8']), ('\U0002f93d', &['\U00025044']), ('\U0002f93e',
+ &['\u3ffc']), ('\U0002f93f', &['\u4008']), ('\U0002f940', &['\u76f4']), ('\U0002f941',
+ &['\U000250f3']), ('\U0002f942', &['\U000250f2']), ('\U0002f943', &['\U00025119']),
+ ('\U0002f944', &['\U00025133']), ('\U0002f945', &['\u771e']), ('\U0002f946', &['\u771f']),
+ ('\U0002f947', &['\u771f']), ('\U0002f948', &['\u774a']), ('\U0002f949', &['\u4039']),
+ ('\U0002f94a', &['\u778b']), ('\U0002f94b', &['\u4046']), ('\U0002f94c', &['\u4096']),
+ ('\U0002f94d', &['\U0002541d']), ('\U0002f94e', &['\u784e']), ('\U0002f94f', &['\u788c']),
+ ('\U0002f950', &['\u78cc']), ('\U0002f951', &['\u40e3']), ('\U0002f952', &['\U00025626']),
+ ('\U0002f953', &['\u7956']), ('\U0002f954', &['\U0002569a']), ('\U0002f955',
+ &['\U000256c5']), ('\U0002f956', &['\u798f']), ('\U0002f957', &['\u79eb']), ('\U0002f958',
+ &['\u412f']), ('\U0002f959', &['\u7a40']), ('\U0002f95a', &['\u7a4a']), ('\U0002f95b',
+ &['\u7a4f']), ('\U0002f95c', &['\U0002597c']), ('\U0002f95d', &['\U00025aa7']),
+ ('\U0002f95e', &['\U00025aa7']), ('\U0002f95f', &['\u7aee']), ('\U0002f960', &['\u4202']),
+ ('\U0002f961', &['\U00025bab']), ('\U0002f962', &['\u7bc6']), ('\U0002f963', &['\u7bc9']),
+ ('\U0002f964', &['\u4227']), ('\U0002f965', &['\U00025c80']), ('\U0002f966', &['\u7cd2']),
+ ('\U0002f967', &['\u42a0']), ('\U0002f968', &['\u7ce8']), ('\U0002f969', &['\u7ce3']),
+ ('\U0002f96a', &['\u7d00']), ('\U0002f96b', &['\U00025f86']), ('\U0002f96c', &['\u7d63']),
+ ('\U0002f96d', &['\u4301']), ('\U0002f96e', &['\u7dc7']), ('\U0002f96f', &['\u7e02']),
+ ('\U0002f970', &['\u7e45']), ('\U0002f971', &['\u4334']), ('\U0002f972', &['\U00026228']),
+ ('\U0002f973', &['\U00026247']), ('\U0002f974', &['\u4359']), ('\U0002f975',
+ &['\U000262d9']), ('\U0002f976', &['\u7f7a']), ('\U0002f977', &['\U0002633e']),
+ ('\U0002f978', &['\u7f95']), ('\U0002f979', &['\u7ffa']), ('\U0002f97a', &['\u8005']),
+ ('\U0002f97b', &['\U000264da']), ('\U0002f97c', &['\U00026523']), ('\U0002f97d',
+ &['\u8060']), ('\U0002f97e', &['\U000265a8']), ('\U0002f97f', &['\u8070']), ('\U0002f980',
+ &['\U0002335f']), ('\U0002f981', &['\u43d5']), ('\U0002f982', &['\u80b2']), ('\U0002f983',
+ &['\u8103']), ('\U0002f984', &['\u440b']), ('\U0002f985', &['\u813e']), ('\U0002f986',
+ &['\u5ab5']), ('\U0002f987', &['\U000267a7']), ('\U0002f988', &['\U000267b5']),
+ ('\U0002f989', &['\U00023393']), ('\U0002f98a', &['\U0002339c']), ('\U0002f98b',
+ &['\u8201']), ('\U0002f98c', &['\u8204']), ('\U0002f98d', &['\u8f9e']), ('\U0002f98e',
+ &['\u446b']), ('\U0002f98f', &['\u8291']), ('\U0002f990', &['\u828b']), ('\U0002f991',
+ &['\u829d']), ('\U0002f992', &['\u52b3']), ('\U0002f993', &['\u82b1']), ('\U0002f994',
+ &['\u82b3']), ('\U0002f995', &['\u82bd']), ('\U0002f996', &['\u82e6']), ('\U0002f997',
+ &['\U00026b3c']), ('\U0002f998', &['\u82e5']), ('\U0002f999', &['\u831d']), ('\U0002f99a',
+ &['\u8363']), ('\U0002f99b', &['\u83ad']), ('\U0002f99c', &['\u8323']), ('\U0002f99d',
+ &['\u83bd']), ('\U0002f99e', &['\u83e7']), ('\U0002f99f', &['\u8457']), ('\U0002f9a0',
+ &['\u8353']), ('\U0002f9a1', &['\u83ca']), ('\U0002f9a2', &['\u83cc']), ('\U0002f9a3',
+ &['\u83dc']), ('\U0002f9a4', &['\U00026c36']), ('\U0002f9a5', &['\U00026d6b']),
+ ('\U0002f9a6', &['\U00026cd5']), ('\U0002f9a7', &['\u452b']), ('\U0002f9a8', &['\u84f1']),
+ ('\U0002f9a9', &['\u84f3']), ('\U0002f9aa', &['\u8516']), ('\U0002f9ab', &['\U000273ca']),
+ ('\U0002f9ac', &['\u8564']), ('\U0002f9ad', &['\U00026f2c']), ('\U0002f9ae', &['\u455d']),
+ ('\U0002f9af', &['\u4561']), ('\U0002f9b0', &['\U00026fb1']), ('\U0002f9b1',
+ &['\U000270d2']), ('\U0002f9b2', &['\u456b']), ('\U0002f9b3', &['\u8650']), ('\U0002f9b4',
+ &['\u865c']), ('\U0002f9b5', &['\u8667']), ('\U0002f9b6', &['\u8669']), ('\U0002f9b7',
+ &['\u86a9']), ('\U0002f9b8', &['\u8688']), ('\U0002f9b9', &['\u870e']), ('\U0002f9ba',
+ &['\u86e2']), ('\U0002f9bb', &['\u8779']), ('\U0002f9bc', &['\u8728']), ('\U0002f9bd',
+ &['\u876b']), ('\U0002f9be', &['\u8786']), ('\U0002f9bf', &['\u45d7']), ('\U0002f9c0',
+ &['\u87e1']), ('\U0002f9c1', &['\u8801']), ('\U0002f9c2', &['\u45f9']), ('\U0002f9c3',
+ &['\u8860']), ('\U0002f9c4', &['\u8863']), ('\U0002f9c5', &['\U00027667']), ('\U0002f9c6',
+ &['\u88d7']), ('\U0002f9c7', &['\u88de']), ('\U0002f9c8', &['\u4635']), ('\U0002f9c9',
+ &['\u88fa']), ('\U0002f9ca', &['\u34bb']), ('\U0002f9cb', &['\U000278ae']), ('\U0002f9cc',
+ &['\U00027966']), ('\U0002f9cd', &['\u46be']), ('\U0002f9ce', &['\u46c7']), ('\U0002f9cf',
+ &['\u8aa0']), ('\U0002f9d0', &['\u8aed']), ('\U0002f9d1', &['\u8b8a']), ('\U0002f9d2',
+ &['\u8c55']), ('\U0002f9d3', &['\U00027ca8']), ('\U0002f9d4', &['\u8cab']), ('\U0002f9d5',
+ &['\u8cc1']), ('\U0002f9d6', &['\u8d1b']), ('\U0002f9d7', &['\u8d77']), ('\U0002f9d8',
+ &['\U00027f2f']), ('\U0002f9d9', &['\U00020804']), ('\U0002f9da', &['\u8dcb']),
+ ('\U0002f9db', &['\u8dbc']), ('\U0002f9dc', &['\u8df0']), ('\U0002f9dd', &['\U000208de']),
+ ('\U0002f9de', &['\u8ed4']), ('\U0002f9df', &['\u8f38']), ('\U0002f9e0', &['\U000285d2']),
+ ('\U0002f9e1', &['\U000285ed']), ('\U0002f9e2', &['\u9094']), ('\U0002f9e3', &['\u90f1']),
+ ('\U0002f9e4', &['\u9111']), ('\U0002f9e5', &['\U0002872e']), ('\U0002f9e6', &['\u911b']),
+ ('\U0002f9e7', &['\u9238']), ('\U0002f9e8', &['\u92d7']), ('\U0002f9e9', &['\u92d8']),
+ ('\U0002f9ea', &['\u927c']), ('\U0002f9eb', &['\u93f9']), ('\U0002f9ec', &['\u9415']),
+ ('\U0002f9ed', &['\U00028bfa']), ('\U0002f9ee', &['\u958b']), ('\U0002f9ef', &['\u4995']),
+ ('\U0002f9f0', &['\u95b7']), ('\U0002f9f1', &['\U00028d77']), ('\U0002f9f2', &['\u49e6']),
+ ('\U0002f9f3', &['\u96c3']), ('\U0002f9f4', &['\u5db2']), ('\U0002f9f5', &['\u9723']),
+ ('\U0002f9f6', &['\U00029145']), ('\U0002f9f7', &['\U0002921a']), ('\U0002f9f8',
+ &['\u4a6e']), ('\U0002f9f9', &['\u4a76']), ('\U0002f9fa', &['\u97e0']), ('\U0002f9fb',
+ &['\U0002940a']), ('\U0002f9fc', &['\u4ab2']), ('\U0002f9fd', &['\U00029496']),
+ ('\U0002f9fe', &['\u980b']), ('\U0002f9ff', &['\u980b']), ('\U0002fa00', &['\u9829']),
+ ('\U0002fa01', &['\U000295b6']), ('\U0002fa02', &['\u98e2']), ('\U0002fa03', &['\u4b33']),
+ ('\U0002fa04', &['\u9929']), ('\U0002fa05', &['\u99a7']), ('\U0002fa06', &['\u99c2']),
+ ('\U0002fa07', &['\u99fe']), ('\U0002fa08', &['\u4bce']), ('\U0002fa09', &['\U00029b30']),
+ ('\U0002fa0a', &['\u9b12']), ('\U0002fa0b', &['\u9c40']), ('\U0002fa0c', &['\u9cfd']),
+ ('\U0002fa0d', &['\u4cce']), ('\U0002fa0e', &['\u4ced']), ('\U0002fa0f', &['\u9d67']),
+ ('\U0002fa10', &['\U0002a0ce']), ('\U0002fa11', &['\u4cf8']), ('\U0002fa12',
+ &['\U0002a105']), ('\U0002fa13', &['\U0002a20e']), ('\U0002fa14', &['\U0002a291']),
+ ('\U0002fa15', &['\u9ebb']), ('\U0002fa16', &['\u4d56']), ('\U0002fa17', &['\u9ef9']),
+ ('\U0002fa18', &['\u9efe']), ('\U0002fa19', &['\u9f05']), ('\U0002fa1a', &['\u9f0f']),
+ ('\U0002fa1b', &['\u9f16']), ('\U0002fa1c', &['\u9f3b']), ('\U0002fa1d', &['\U0002a600'])
+ ];
+
+ // Compatibility decompositions
+ pub static compatibility_table: &'static [(char, &'static [char])] = &[
+ ('\xa0', &['\x20']), ('\xa8', &['\x20', '\u0308']), ('\xaa', &['\x61']), ('\xaf', &['\x20',
+ '\u0304']), ('\xb2', &['\x32']), ('\xb3', &['\x33']), ('\xb4', &['\x20', '\u0301']),
+ ('\xb5', &['\u03bc']), ('\xb8', &['\x20', '\u0327']), ('\xb9', &['\x31']), ('\xba',
+ &['\x6f']), ('\xbc', &['\x31', '\u2044', '\x34']), ('\xbd', &['\x31', '\u2044', '\x32']),
+ ('\xbe', &['\x33', '\u2044', '\x34']), ('\u0132', &['\x49', '\x4a']), ('\u0133', &['\x69',
+ '\x6a']), ('\u013f', &['\x4c', '\xb7']), ('\u0140', &['\x6c', '\xb7']), ('\u0149',
+ &['\u02bc', '\x6e']), ('\u017f', &['\x73']), ('\u01c4', &['\x44', '\u017d']), ('\u01c5',
+ &['\x44', '\u017e']), ('\u01c6', &['\x64', '\u017e']), ('\u01c7', &['\x4c', '\x4a']),
+ ('\u01c8', &['\x4c', '\x6a']), ('\u01c9', &['\x6c', '\x6a']), ('\u01ca', &['\x4e', '\x4a']),
+ ('\u01cb', &['\x4e', '\x6a']), ('\u01cc', &['\x6e', '\x6a']), ('\u01f1', &['\x44', '\x5a']),
+ ('\u01f2', &['\x44', '\x7a']), ('\u01f3', &['\x64', '\x7a']), ('\u02b0', &['\x68']),
+ ('\u02b1', &['\u0266']), ('\u02b2', &['\x6a']), ('\u02b3', &['\x72']), ('\u02b4',
+ &['\u0279']), ('\u02b5', &['\u027b']), ('\u02b6', &['\u0281']), ('\u02b7', &['\x77']),
+ ('\u02b8', &['\x79']), ('\u02d8', &['\x20', '\u0306']), ('\u02d9', &['\x20', '\u0307']),
+ ('\u02da', &['\x20', '\u030a']), ('\u02db', &['\x20', '\u0328']), ('\u02dc', &['\x20',
+ '\u0303']), ('\u02dd', &['\x20', '\u030b']), ('\u02e0', &['\u0263']), ('\u02e1', &['\x6c']),
+ ('\u02e2', &['\x73']), ('\u02e3', &['\x78']), ('\u02e4', &['\u0295']), ('\u037a', &['\x20',
+ '\u0345']), ('\u0384', &['\x20', '\u0301']), ('\u03d0', &['\u03b2']), ('\u03d1',
+ &['\u03b8']), ('\u03d2', &['\u03a5']), ('\u03d5', &['\u03c6']), ('\u03d6', &['\u03c0']),
+ ('\u03f0', &['\u03ba']), ('\u03f1', &['\u03c1']), ('\u03f2', &['\u03c2']), ('\u03f4',
+ &['\u0398']), ('\u03f5', &['\u03b5']), ('\u03f9', &['\u03a3']), ('\u0587', &['\u0565',
+ '\u0582']), ('\u0675', &['\u0627', '\u0674']), ('\u0676', &['\u0648', '\u0674']), ('\u0677',
+ &['\u06c7', '\u0674']), ('\u0678', &['\u064a', '\u0674']), ('\u0e33', &['\u0e4d',
+ '\u0e32']), ('\u0eb3', &['\u0ecd', '\u0eb2']), ('\u0edc', &['\u0eab', '\u0e99']), ('\u0edd',
+ &['\u0eab', '\u0ea1']), ('\u0f0c', &['\u0f0b']), ('\u0f77', &['\u0fb2', '\u0f81']),
+ ('\u0f79', &['\u0fb3', '\u0f81']), ('\u10fc', &['\u10dc']), ('\u1d2c', &['\x41']),
+ ('\u1d2d', &['\xc6']), ('\u1d2e', &['\x42']), ('\u1d30', &['\x44']), ('\u1d31', &['\x45']),
+ ('\u1d32', &['\u018e']), ('\u1d33', &['\x47']), ('\u1d34', &['\x48']), ('\u1d35',
+ &['\x49']), ('\u1d36', &['\x4a']), ('\u1d37', &['\x4b']), ('\u1d38', &['\x4c']), ('\u1d39',
+ &['\x4d']), ('\u1d3a', &['\x4e']), ('\u1d3c', &['\x4f']), ('\u1d3d', &['\u0222']),
+ ('\u1d3e', &['\x50']), ('\u1d3f', &['\x52']), ('\u1d40', &['\x54']), ('\u1d41', &['\x55']),
+ ('\u1d42', &['\x57']), ('\u1d43', &['\x61']), ('\u1d44', &['\u0250']), ('\u1d45',
+ &['\u0251']), ('\u1d46', &['\u1d02']), ('\u1d47', &['\x62']), ('\u1d48', &['\x64']),
+ ('\u1d49', &['\x65']), ('\u1d4a', &['\u0259']), ('\u1d4b', &['\u025b']), ('\u1d4c',
+ &['\u025c']), ('\u1d4d', &['\x67']), ('\u1d4f', &['\x6b']), ('\u1d50', &['\x6d']),
+ ('\u1d51', &['\u014b']), ('\u1d52', &['\x6f']), ('\u1d53', &['\u0254']), ('\u1d54',
+ &['\u1d16']), ('\u1d55', &['\u1d17']), ('\u1d56', &['\x70']), ('\u1d57', &['\x74']),
+ ('\u1d58', &['\x75']), ('\u1d59', &['\u1d1d']), ('\u1d5a', &['\u026f']), ('\u1d5b',
+ &['\x76']), ('\u1d5c', &['\u1d25']), ('\u1d5d', &['\u03b2']), ('\u1d5e', &['\u03b3']),
+ ('\u1d5f', &['\u03b4']), ('\u1d60', &['\u03c6']), ('\u1d61', &['\u03c7']), ('\u1d62',
+ &['\x69']), ('\u1d63', &['\x72']), ('\u1d64', &['\x75']), ('\u1d65', &['\x76']), ('\u1d66',
+ &['\u03b2']), ('\u1d67', &['\u03b3']), ('\u1d68', &['\u03c1']), ('\u1d69', &['\u03c6']),
+ ('\u1d6a', &['\u03c7']), ('\u1d78', &['\u043d']), ('\u1d9b', &['\u0252']), ('\u1d9c',
+ &['\x63']), ('\u1d9d', &['\u0255']), ('\u1d9e', &['\xf0']), ('\u1d9f', &['\u025c']),
+ ('\u1da0', &['\x66']), ('\u1da1', &['\u025f']), ('\u1da2', &['\u0261']), ('\u1da3',
+ &['\u0265']), ('\u1da4', &['\u0268']), ('\u1da5', &['\u0269']), ('\u1da6', &['\u026a']),
+ ('\u1da7', &['\u1d7b']), ('\u1da8', &['\u029d']), ('\u1da9', &['\u026d']), ('\u1daa',
+ &['\u1d85']), ('\u1dab', &['\u029f']), ('\u1dac', &['\u0271']), ('\u1dad', &['\u0270']),
+ ('\u1dae', &['\u0272']), ('\u1daf', &['\u0273']), ('\u1db0', &['\u0274']), ('\u1db1',
+ &['\u0275']), ('\u1db2', &['\u0278']), ('\u1db3', &['\u0282']), ('\u1db4', &['\u0283']),
+ ('\u1db5', &['\u01ab']), ('\u1db6', &['\u0289']), ('\u1db7', &['\u028a']), ('\u1db8',
+ &['\u1d1c']), ('\u1db9', &['\u028b']), ('\u1dba', &['\u028c']), ('\u1dbb', &['\x7a']),
+ ('\u1dbc', &['\u0290']), ('\u1dbd', &['\u0291']), ('\u1dbe', &['\u0292']), ('\u1dbf',
+ &['\u03b8']), ('\u1e9a', &['\x61', '\u02be']), ('\u1fbd', &['\x20', '\u0313']), ('\u1fbf',
+ &['\x20', '\u0313']), ('\u1fc0', &['\x20', '\u0342']), ('\u1ffe', &['\x20', '\u0314']),
+ ('\u2002', &['\x20']), ('\u2003', &['\x20']), ('\u2004', &['\x20']), ('\u2005', &['\x20']),
+ ('\u2006', &['\x20']), ('\u2007', &['\x20']), ('\u2008', &['\x20']), ('\u2009', &['\x20']),
+ ('\u200a', &['\x20']), ('\u2011', &['\u2010']), ('\u2017', &['\x20', '\u0333']), ('\u2024',
+ &['\x2e']), ('\u2025', &['\x2e', '\x2e']), ('\u2026', &['\x2e', '\x2e', '\x2e']), ('\u202f',
+ &['\x20']), ('\u2033', &['\u2032', '\u2032']), ('\u2034', &['\u2032', '\u2032', '\u2032']),
+ ('\u2036', &['\u2035', '\u2035']), ('\u2037', &['\u2035', '\u2035', '\u2035']), ('\u203c',
+ &['\x21', '\x21']), ('\u203e', &['\x20', '\u0305']), ('\u2047', &['\x3f', '\x3f']),
+ ('\u2048', &['\x3f', '\x21']), ('\u2049', &['\x21', '\x3f']), ('\u2057', &['\u2032',
+ '\u2032', '\u2032', '\u2032']), ('\u205f', &['\x20']), ('\u2070', &['\x30']), ('\u2071',
+ &['\x69']), ('\u2074', &['\x34']), ('\u2075', &['\x35']), ('\u2076', &['\x36']), ('\u2077',
+ &['\x37']), ('\u2078', &['\x38']), ('\u2079', &['\x39']), ('\u207a', &['\x2b']), ('\u207b',
+ &['\u2212']), ('\u207c', &['\x3d']), ('\u207d', &['\x28']), ('\u207e', &['\x29']),
+ ('\u207f', &['\x6e']), ('\u2080', &['\x30']), ('\u2081', &['\x31']), ('\u2082', &['\x32']),
+ ('\u2083', &['\x33']), ('\u2084', &['\x34']), ('\u2085', &['\x35']), ('\u2086', &['\x36']),
+ ('\u2087', &['\x37']), ('\u2088', &['\x38']), ('\u2089', &['\x39']), ('\u208a', &['\x2b']),
+ ('\u208b', &['\u2212']), ('\u208c', &['\x3d']), ('\u208d', &['\x28']), ('\u208e',
+ &['\x29']), ('\u2090', &['\x61']), ('\u2091', &['\x65']), ('\u2092', &['\x6f']), ('\u2093',
+ &['\x78']), ('\u2094', &['\u0259']), ('\u2095', &['\x68']), ('\u2096', &['\x6b']),
+ ('\u2097', &['\x6c']), ('\u2098', &['\x6d']), ('\u2099', &['\x6e']), ('\u209a', &['\x70']),
+ ('\u209b', &['\x73']), ('\u209c', &['\x74']), ('\u20a8', &['\x52', '\x73']), ('\u2100',
+ &['\x61', '\x2f', '\x63']), ('\u2101', &['\x61', '\x2f', '\x73']), ('\u2102', &['\x43']),
+ ('\u2103', &['\xb0', '\x43']), ('\u2105', &['\x63', '\x2f', '\x6f']), ('\u2106', &['\x63',
+ '\x2f', '\x75']), ('\u2107', &['\u0190']), ('\u2109', &['\xb0', '\x46']), ('\u210a',
+ &['\x67']), ('\u210b', &['\x48']), ('\u210c', &['\x48']), ('\u210d', &['\x48']), ('\u210e',
+ &['\x68']), ('\u210f', &['\u0127']), ('\u2110', &['\x49']), ('\u2111', &['\x49']),
+ ('\u2112', &['\x4c']), ('\u2113', &['\x6c']), ('\u2115', &['\x4e']), ('\u2116', &['\x4e',
+ '\x6f']), ('\u2119', &['\x50']), ('\u211a', &['\x51']), ('\u211b', &['\x52']), ('\u211c',
+ &['\x52']), ('\u211d', &['\x52']), ('\u2120', &['\x53', '\x4d']), ('\u2121', &['\x54',
+ '\x45', '\x4c']), ('\u2122', &['\x54', '\x4d']), ('\u2124', &['\x5a']), ('\u2128',
+ &['\x5a']), ('\u212c', &['\x42']), ('\u212d', &['\x43']), ('\u212f', &['\x65']), ('\u2130',
+ &['\x45']), ('\u2131', &['\x46']), ('\u2133', &['\x4d']), ('\u2134', &['\x6f']), ('\u2135',
+ &['\u05d0']), ('\u2136', &['\u05d1']), ('\u2137', &['\u05d2']), ('\u2138', &['\u05d3']),
+ ('\u2139', &['\x69']), ('\u213b', &['\x46', '\x41', '\x58']), ('\u213c', &['\u03c0']),
+ ('\u213d', &['\u03b3']), ('\u213e', &['\u0393']), ('\u213f', &['\u03a0']), ('\u2140',
+ &['\u2211']), ('\u2145', &['\x44']), ('\u2146', &['\x64']), ('\u2147', &['\x65']),
+ ('\u2148', &['\x69']), ('\u2149', &['\x6a']), ('\u2150', &['\x31', '\u2044', '\x37']),
+ ('\u2151', &['\x31', '\u2044', '\x39']), ('\u2152', &['\x31', '\u2044', '\x31', '\x30']),
+ ('\u2153', &['\x31', '\u2044', '\x33']), ('\u2154', &['\x32', '\u2044', '\x33']), ('\u2155',
+ &['\x31', '\u2044', '\x35']), ('\u2156', &['\x32', '\u2044', '\x35']), ('\u2157', &['\x33',
+ '\u2044', '\x35']), ('\u2158', &['\x34', '\u2044', '\x35']), ('\u2159', &['\x31', '\u2044',
+ '\x36']), ('\u215a', &['\x35', '\u2044', '\x36']), ('\u215b', &['\x31', '\u2044', '\x38']),
+ ('\u215c', &['\x33', '\u2044', '\x38']), ('\u215d', &['\x35', '\u2044', '\x38']), ('\u215e',
+ &['\x37', '\u2044', '\x38']), ('\u215f', &['\x31', '\u2044']), ('\u2160', &['\x49']),
+ ('\u2161', &['\x49', '\x49']), ('\u2162', &['\x49', '\x49', '\x49']), ('\u2163', &['\x49',
+ '\x56']), ('\u2164', &['\x56']), ('\u2165', &['\x56', '\x49']), ('\u2166', &['\x56', '\x49',
+ '\x49']), ('\u2167', &['\x56', '\x49', '\x49', '\x49']), ('\u2168', &['\x49', '\x58']),
+ ('\u2169', &['\x58']), ('\u216a', &['\x58', '\x49']), ('\u216b', &['\x58', '\x49', '\x49']),
+ ('\u216c', &['\x4c']), ('\u216d', &['\x43']), ('\u216e', &['\x44']), ('\u216f', &['\x4d']),
+ ('\u2170', &['\x69']), ('\u2171', &['\x69', '\x69']), ('\u2172', &['\x69', '\x69', '\x69']),
+ ('\u2173', &['\x69', '\x76']), ('\u2174', &['\x76']), ('\u2175', &['\x76', '\x69']),
+ ('\u2176', &['\x76', '\x69', '\x69']), ('\u2177', &['\x76', '\x69', '\x69', '\x69']),
+ ('\u2178', &['\x69', '\x78']), ('\u2179', &['\x78']), ('\u217a', &['\x78', '\x69']),
+ ('\u217b', &['\x78', '\x69', '\x69']), ('\u217c', &['\x6c']), ('\u217d', &['\x63']),
+ ('\u217e', &['\x64']), ('\u217f', &['\x6d']), ('\u2189', &['\x30', '\u2044', '\x33']),
+ ('\u222c', &['\u222b', '\u222b']), ('\u222d', &['\u222b', '\u222b', '\u222b']), ('\u222f',
+ &['\u222e', '\u222e']), ('\u2230', &['\u222e', '\u222e', '\u222e']), ('\u2460', &['\x31']),
+ ('\u2461', &['\x32']), ('\u2462', &['\x33']), ('\u2463', &['\x34']), ('\u2464', &['\x35']),
+ ('\u2465', &['\x36']), ('\u2466', &['\x37']), ('\u2467', &['\x38']), ('\u2468', &['\x39']),
+ ('\u2469', &['\x31', '\x30']), ('\u246a', &['\x31', '\x31']), ('\u246b', &['\x31', '\x32']),
+ ('\u246c', &['\x31', '\x33']), ('\u246d', &['\x31', '\x34']), ('\u246e', &['\x31', '\x35']),
+ ('\u246f', &['\x31', '\x36']), ('\u2470', &['\x31', '\x37']), ('\u2471', &['\x31', '\x38']),
+ ('\u2472', &['\x31', '\x39']), ('\u2473', &['\x32', '\x30']), ('\u2474', &['\x28', '\x31',
+ '\x29']), ('\u2475', &['\x28', '\x32', '\x29']), ('\u2476', &['\x28', '\x33', '\x29']),
+ ('\u2477', &['\x28', '\x34', '\x29']), ('\u2478', &['\x28', '\x35', '\x29']), ('\u2479',
+ &['\x28', '\x36', '\x29']), ('\u247a', &['\x28', '\x37', '\x29']), ('\u247b', &['\x28',
+ '\x38', '\x29']), ('\u247c', &['\x28', '\x39', '\x29']), ('\u247d', &['\x28', '\x31',
+ '\x30', '\x29']), ('\u247e', &['\x28', '\x31', '\x31', '\x29']), ('\u247f', &['\x28',
+ '\x31', '\x32', '\x29']), ('\u2480', &['\x28', '\x31', '\x33', '\x29']), ('\u2481',
+ &['\x28', '\x31', '\x34', '\x29']), ('\u2482', &['\x28', '\x31', '\x35', '\x29']),
+ ('\u2483', &['\x28', '\x31', '\x36', '\x29']), ('\u2484', &['\x28', '\x31', '\x37',
+ '\x29']), ('\u2485', &['\x28', '\x31', '\x38', '\x29']), ('\u2486', &['\x28', '\x31',
+ '\x39', '\x29']), ('\u2487', &['\x28', '\x32', '\x30', '\x29']), ('\u2488', &['\x31',
+ '\x2e']), ('\u2489', &['\x32', '\x2e']), ('\u248a', &['\x33', '\x2e']), ('\u248b', &['\x34',
+ '\x2e']), ('\u248c', &['\x35', '\x2e']), ('\u248d', &['\x36', '\x2e']), ('\u248e', &['\x37',
+ '\x2e']), ('\u248f', &['\x38', '\x2e']), ('\u2490', &['\x39', '\x2e']), ('\u2491', &['\x31',
+ '\x30', '\x2e']), ('\u2492', &['\x31', '\x31', '\x2e']), ('\u2493', &['\x31', '\x32',
+ '\x2e']), ('\u2494', &['\x31', '\x33', '\x2e']), ('\u2495', &['\x31', '\x34', '\x2e']),
+ ('\u2496', &['\x31', '\x35', '\x2e']), ('\u2497', &['\x31', '\x36', '\x2e']), ('\u2498',
+ &['\x31', '\x37', '\x2e']), ('\u2499', &['\x31', '\x38', '\x2e']), ('\u249a', &['\x31',
+ '\x39', '\x2e']), ('\u249b', &['\x32', '\x30', '\x2e']), ('\u249c', &['\x28', '\x61',
+ '\x29']), ('\u249d', &['\x28', '\x62', '\x29']), ('\u249e', &['\x28', '\x63', '\x29']),
+ ('\u249f', &['\x28', '\x64', '\x29']), ('\u24a0', &['\x28', '\x65', '\x29']), ('\u24a1',
+ &['\x28', '\x66', '\x29']), ('\u24a2', &['\x28', '\x67', '\x29']), ('\u24a3', &['\x28',
+ '\x68', '\x29']), ('\u24a4', &['\x28', '\x69', '\x29']), ('\u24a5', &['\x28', '\x6a',
+ '\x29']), ('\u24a6', &['\x28', '\x6b', '\x29']), ('\u24a7', &['\x28', '\x6c', '\x29']),
+ ('\u24a8', &['\x28', '\x6d', '\x29']), ('\u24a9', &['\x28', '\x6e', '\x29']), ('\u24aa',
+ &['\x28', '\x6f', '\x29']), ('\u24ab', &['\x28', '\x70', '\x29']), ('\u24ac', &['\x28',
+ '\x71', '\x29']), ('\u24ad', &['\x28', '\x72', '\x29']), ('\u24ae', &['\x28', '\x73',
+ '\x29']), ('\u24af', &['\x28', '\x74', '\x29']), ('\u24b0', &['\x28', '\x75', '\x29']),
+ ('\u24b1', &['\x28', '\x76', '\x29']), ('\u24b2', &['\x28', '\x77', '\x29']), ('\u24b3',
+ &['\x28', '\x78', '\x29']), ('\u24b4', &['\x28', '\x79', '\x29']), ('\u24b5', &['\x28',
+ '\x7a', '\x29']), ('\u24b6', &['\x41']), ('\u24b7', &['\x42']), ('\u24b8', &['\x43']),
+ ('\u24b9', &['\x44']), ('\u24ba', &['\x45']), ('\u24bb', &['\x46']), ('\u24bc', &['\x47']),
+ ('\u24bd', &['\x48']), ('\u24be', &['\x49']), ('\u24bf', &['\x4a']), ('\u24c0', &['\x4b']),
+ ('\u24c1', &['\x4c']), ('\u24c2', &['\x4d']), ('\u24c3', &['\x4e']), ('\u24c4', &['\x4f']),
+ ('\u24c5', &['\x50']), ('\u24c6', &['\x51']), ('\u24c7', &['\x52']), ('\u24c8', &['\x53']),
+ ('\u24c9', &['\x54']), ('\u24ca', &['\x55']), ('\u24cb', &['\x56']), ('\u24cc', &['\x57']),
+ ('\u24cd', &['\x58']), ('\u24ce', &['\x59']), ('\u24cf', &['\x5a']), ('\u24d0', &['\x61']),
+ ('\u24d1', &['\x62']), ('\u24d2', &['\x63']), ('\u24d3', &['\x64']), ('\u24d4', &['\x65']),
+ ('\u24d5', &['\x66']), ('\u24d6', &['\x67']), ('\u24d7', &['\x68']), ('\u24d8', &['\x69']),
+ ('\u24d9', &['\x6a']), ('\u24da', &['\x6b']), ('\u24db', &['\x6c']), ('\u24dc', &['\x6d']),
+ ('\u24dd', &['\x6e']), ('\u24de', &['\x6f']), ('\u24df', &['\x70']), ('\u24e0', &['\x71']),
+ ('\u24e1', &['\x72']), ('\u24e2', &['\x73']), ('\u24e3', &['\x74']), ('\u24e4', &['\x75']),
+ ('\u24e5', &['\x76']), ('\u24e6', &['\x77']), ('\u24e7', &['\x78']), ('\u24e8', &['\x79']),
+ ('\u24e9', &['\x7a']), ('\u24ea', &['\x30']), ('\u2a0c', &['\u222b', '\u222b', '\u222b',
+ '\u222b']), ('\u2a74', &['\x3a', '\x3a', '\x3d']), ('\u2a75', &['\x3d', '\x3d']), ('\u2a76',
+ &['\x3d', '\x3d', '\x3d']), ('\u2c7c', &['\x6a']), ('\u2c7d', &['\x56']), ('\u2d6f',
+ &['\u2d61']), ('\u2e9f', &['\u6bcd']), ('\u2ef3', &['\u9f9f']), ('\u2f00', &['\u4e00']),
+ ('\u2f01', &['\u4e28']), ('\u2f02', &['\u4e36']), ('\u2f03', &['\u4e3f']), ('\u2f04',
+ &['\u4e59']), ('\u2f05', &['\u4e85']), ('\u2f06', &['\u4e8c']), ('\u2f07', &['\u4ea0']),
+ ('\u2f08', &['\u4eba']), ('\u2f09', &['\u513f']), ('\u2f0a', &['\u5165']), ('\u2f0b',
+ &['\u516b']), ('\u2f0c', &['\u5182']), ('\u2f0d', &['\u5196']), ('\u2f0e', &['\u51ab']),
+ ('\u2f0f', &['\u51e0']), ('\u2f10', &['\u51f5']), ('\u2f11', &['\u5200']), ('\u2f12',
+ &['\u529b']), ('\u2f13', &['\u52f9']), ('\u2f14', &['\u5315']), ('\u2f15', &['\u531a']),
+ ('\u2f16', &['\u5338']), ('\u2f17', &['\u5341']), ('\u2f18', &['\u535c']), ('\u2f19',
+ &['\u5369']), ('\u2f1a', &['\u5382']), ('\u2f1b', &['\u53b6']), ('\u2f1c', &['\u53c8']),
+ ('\u2f1d', &['\u53e3']), ('\u2f1e', &['\u56d7']), ('\u2f1f', &['\u571f']), ('\u2f20',
+ &['\u58eb']), ('\u2f21', &['\u5902']), ('\u2f22', &['\u590a']), ('\u2f23', &['\u5915']),
+ ('\u2f24', &['\u5927']), ('\u2f25', &['\u5973']), ('\u2f26', &['\u5b50']), ('\u2f27',
+ &['\u5b80']), ('\u2f28', &['\u5bf8']), ('\u2f29', &['\u5c0f']), ('\u2f2a', &['\u5c22']),
+ ('\u2f2b', &['\u5c38']), ('\u2f2c', &['\u5c6e']), ('\u2f2d', &['\u5c71']), ('\u2f2e',
+ &['\u5ddb']), ('\u2f2f', &['\u5de5']), ('\u2f30', &['\u5df1']), ('\u2f31', &['\u5dfe']),
+ ('\u2f32', &['\u5e72']), ('\u2f33', &['\u5e7a']), ('\u2f34', &['\u5e7f']), ('\u2f35',
+ &['\u5ef4']), ('\u2f36', &['\u5efe']), ('\u2f37', &['\u5f0b']), ('\u2f38', &['\u5f13']),
+ ('\u2f39', &['\u5f50']), ('\u2f3a', &['\u5f61']), ('\u2f3b', &['\u5f73']), ('\u2f3c',
+ &['\u5fc3']), ('\u2f3d', &['\u6208']), ('\u2f3e', &['\u6236']), ('\u2f3f', &['\u624b']),
+ ('\u2f40', &['\u652f']), ('\u2f41', &['\u6534']), ('\u2f42', &['\u6587']), ('\u2f43',
+ &['\u6597']), ('\u2f44', &['\u65a4']), ('\u2f45', &['\u65b9']), ('\u2f46', &['\u65e0']),
+ ('\u2f47', &['\u65e5']), ('\u2f48', &['\u66f0']), ('\u2f49', &['\u6708']), ('\u2f4a',
+ &['\u6728']), ('\u2f4b', &['\u6b20']), ('\u2f4c', &['\u6b62']), ('\u2f4d', &['\u6b79']),
+ ('\u2f4e', &['\u6bb3']), ('\u2f4f', &['\u6bcb']), ('\u2f50', &['\u6bd4']), ('\u2f51',
+ &['\u6bdb']), ('\u2f52', &['\u6c0f']), ('\u2f53', &['\u6c14']), ('\u2f54', &['\u6c34']),
+ ('\u2f55', &['\u706b']), ('\u2f56', &['\u722a']), ('\u2f57', &['\u7236']), ('\u2f58',
+ &['\u723b']), ('\u2f59', &['\u723f']), ('\u2f5a', &['\u7247']), ('\u2f5b', &['\u7259']),
+ ('\u2f5c', &['\u725b']), ('\u2f5d', &['\u72ac']), ('\u2f5e', &['\u7384']), ('\u2f5f',
+ &['\u7389']), ('\u2f60', &['\u74dc']), ('\u2f61', &['\u74e6']), ('\u2f62', &['\u7518']),
+ ('\u2f63', &['\u751f']), ('\u2f64', &['\u7528']), ('\u2f65', &['\u7530']), ('\u2f66',
+ &['\u758b']), ('\u2f67', &['\u7592']), ('\u2f68', &['\u7676']), ('\u2f69', &['\u767d']),
+ ('\u2f6a', &['\u76ae']), ('\u2f6b', &['\u76bf']), ('\u2f6c', &['\u76ee']), ('\u2f6d',
+ &['\u77db']), ('\u2f6e', &['\u77e2']), ('\u2f6f', &['\u77f3']), ('\u2f70', &['\u793a']),
+ ('\u2f71', &['\u79b8']), ('\u2f72', &['\u79be']), ('\u2f73', &['\u7a74']), ('\u2f74',
+ &['\u7acb']), ('\u2f75', &['\u7af9']), ('\u2f76', &['\u7c73']), ('\u2f77', &['\u7cf8']),
+ ('\u2f78', &['\u7f36']), ('\u2f79', &['\u7f51']), ('\u2f7a', &['\u7f8a']), ('\u2f7b',
+ &['\u7fbd']), ('\u2f7c', &['\u8001']), ('\u2f7d', &['\u800c']), ('\u2f7e', &['\u8012']),
+ ('\u2f7f', &['\u8033']), ('\u2f80', &['\u807f']), ('\u2f81', &['\u8089']), ('\u2f82',
+ &['\u81e3']), ('\u2f83', &['\u81ea']), ('\u2f84', &['\u81f3']), ('\u2f85', &['\u81fc']),
+ ('\u2f86', &['\u820c']), ('\u2f87', &['\u821b']), ('\u2f88', &['\u821f']), ('\u2f89',
+ &['\u826e']), ('\u2f8a', &['\u8272']), ('\u2f8b', &['\u8278']), ('\u2f8c', &['\u864d']),
+ ('\u2f8d', &['\u866b']), ('\u2f8e', &['\u8840']), ('\u2f8f', &['\u884c']), ('\u2f90',
+ &['\u8863']), ('\u2f91', &['\u897e']), ('\u2f92', &['\u898b']), ('\u2f93', &['\u89d2']),
+ ('\u2f94', &['\u8a00']), ('\u2f95', &['\u8c37']), ('\u2f96', &['\u8c46']), ('\u2f97',
+ &['\u8c55']), ('\u2f98', &['\u8c78']), ('\u2f99', &['\u8c9d']), ('\u2f9a', &['\u8d64']),
+ ('\u2f9b', &['\u8d70']), ('\u2f9c', &['\u8db3']), ('\u2f9d', &['\u8eab']), ('\u2f9e',
+ &['\u8eca']), ('\u2f9f', &['\u8f9b']), ('\u2fa0', &['\u8fb0']), ('\u2fa1', &['\u8fb5']),
+ ('\u2fa2', &['\u9091']), ('\u2fa3', &['\u9149']), ('\u2fa4', &['\u91c6']), ('\u2fa5',
+ &['\u91cc']), ('\u2fa6', &['\u91d1']), ('\u2fa7', &['\u9577']), ('\u2fa8', &['\u9580']),
+ ('\u2fa9', &['\u961c']), ('\u2faa', &['\u96b6']), ('\u2fab', &['\u96b9']), ('\u2fac',
+ &['\u96e8']), ('\u2fad', &['\u9751']), ('\u2fae', &['\u975e']), ('\u2faf', &['\u9762']),
+ ('\u2fb0', &['\u9769']), ('\u2fb1', &['\u97cb']), ('\u2fb2', &['\u97ed']), ('\u2fb3',
+ &['\u97f3']), ('\u2fb4', &['\u9801']), ('\u2fb5', &['\u98a8']), ('\u2fb6', &['\u98db']),
+ ('\u2fb7', &['\u98df']), ('\u2fb8', &['\u9996']), ('\u2fb9', &['\u9999']), ('\u2fba',
+ &['\u99ac']), ('\u2fbb', &['\u9aa8']), ('\u2fbc', &['\u9ad8']), ('\u2fbd', &['\u9adf']),
+ ('\u2fbe', &['\u9b25']), ('\u2fbf', &['\u9b2f']), ('\u2fc0', &['\u9b32']), ('\u2fc1',
+ &['\u9b3c']), ('\u2fc2', &['\u9b5a']), ('\u2fc3', &['\u9ce5']), ('\u2fc4', &['\u9e75']),
+ ('\u2fc5', &['\u9e7f']), ('\u2fc6', &['\u9ea5']), ('\u2fc7', &['\u9ebb']), ('\u2fc8',
+ &['\u9ec3']), ('\u2fc9', &['\u9ecd']), ('\u2fca', &['\u9ed1']), ('\u2fcb', &['\u9ef9']),
+ ('\u2fcc', &['\u9efd']), ('\u2fcd', &['\u9f0e']), ('\u2fce', &['\u9f13']), ('\u2fcf',
+ &['\u9f20']), ('\u2fd0', &['\u9f3b']), ('\u2fd1', &['\u9f4a']), ('\u2fd2', &['\u9f52']),
+ ('\u2fd3', &['\u9f8d']), ('\u2fd4', &['\u9f9c']), ('\u2fd5', &['\u9fa0']), ('\u3000',
+ &['\x20']), ('\u3036', &['\u3012']), ('\u3038', &['\u5341']), ('\u3039', &['\u5344']),
+ ('\u303a', &['\u5345']), ('\u309b', &['\x20', '\u3099']), ('\u309c', &['\x20', '\u309a']),
+ ('\u309f', &['\u3088', '\u308a']), ('\u30ff', &['\u30b3', '\u30c8']), ('\u3131',
+ &['\u1100']), ('\u3132', &['\u1101']), ('\u3133', &['\u11aa']), ('\u3134', &['\u1102']),
+ ('\u3135', &['\u11ac']), ('\u3136', &['\u11ad']), ('\u3137', &['\u1103']), ('\u3138',
+ &['\u1104']), ('\u3139', &['\u1105']), ('\u313a', &['\u11b0']), ('\u313b', &['\u11b1']),
+ ('\u313c', &['\u11b2']), ('\u313d', &['\u11b3']), ('\u313e', &['\u11b4']), ('\u313f',
+ &['\u11b5']), ('\u3140', &['\u111a']), ('\u3141', &['\u1106']), ('\u3142', &['\u1107']),
+ ('\u3143', &['\u1108']), ('\u3144', &['\u1121']), ('\u3145', &['\u1109']), ('\u3146',
+ &['\u110a']), ('\u3147', &['\u110b']), ('\u3148', &['\u110c']), ('\u3149', &['\u110d']),
+ ('\u314a', &['\u110e']), ('\u314b', &['\u110f']), ('\u314c', &['\u1110']), ('\u314d',
+ &['\u1111']), ('\u314e', &['\u1112']), ('\u314f', &['\u1161']), ('\u3150', &['\u1162']),
+ ('\u3151', &['\u1163']), ('\u3152', &['\u1164']), ('\u3153', &['\u1165']), ('\u3154',
+ &['\u1166']), ('\u3155', &['\u1167']), ('\u3156', &['\u1168']), ('\u3157', &['\u1169']),
+ ('\u3158', &['\u116a']), ('\u3159', &['\u116b']), ('\u315a', &['\u116c']), ('\u315b',
+ &['\u116d']), ('\u315c', &['\u116e']), ('\u315d', &['\u116f']), ('\u315e', &['\u1170']),
+ ('\u315f', &['\u1171']), ('\u3160', &['\u1172']), ('\u3161', &['\u1173']), ('\u3162',
+ &['\u1174']), ('\u3163', &['\u1175']), ('\u3164', &['\u1160']), ('\u3165', &['\u1114']),
+ ('\u3166', &['\u1115']), ('\u3167', &['\u11c7']), ('\u3168', &['\u11c8']), ('\u3169',
+ &['\u11cc']), ('\u316a', &['\u11ce']), ('\u316b', &['\u11d3']), ('\u316c', &['\u11d7']),
+ ('\u316d', &['\u11d9']), ('\u316e', &['\u111c']), ('\u316f', &['\u11dd']), ('\u3170',
+ &['\u11df']), ('\u3171', &['\u111d']), ('\u3172', &['\u111e']), ('\u3173', &['\u1120']),
+ ('\u3174', &['\u1122']), ('\u3175', &['\u1123']), ('\u3176', &['\u1127']), ('\u3177',
+ &['\u1129']), ('\u3178', &['\u112b']), ('\u3179', &['\u112c']), ('\u317a', &['\u112d']),
+ ('\u317b', &['\u112e']), ('\u317c', &['\u112f']), ('\u317d', &['\u1132']), ('\u317e',
+ &['\u1136']), ('\u317f', &['\u1140']), ('\u3180', &['\u1147']), ('\u3181', &['\u114c']),
+ ('\u3182', &['\u11f1']), ('\u3183', &['\u11f2']), ('\u3184', &['\u1157']), ('\u3185',
+ &['\u1158']), ('\u3186', &['\u1159']), ('\u3187', &['\u1184']), ('\u3188', &['\u1185']),
+ ('\u3189', &['\u1188']), ('\u318a', &['\u1191']), ('\u318b', &['\u1192']), ('\u318c',
+ &['\u1194']), ('\u318d', &['\u119e']), ('\u318e', &['\u11a1']), ('\u3192', &['\u4e00']),
+ ('\u3193', &['\u4e8c']), ('\u3194', &['\u4e09']), ('\u3195', &['\u56db']), ('\u3196',
+ &['\u4e0a']), ('\u3197', &['\u4e2d']), ('\u3198', &['\u4e0b']), ('\u3199', &['\u7532']),
+ ('\u319a', &['\u4e59']), ('\u319b', &['\u4e19']), ('\u319c', &['\u4e01']), ('\u319d',
+ &['\u5929']), ('\u319e', &['\u5730']), ('\u319f', &['\u4eba']), ('\u3200', &['\x28',
+ '\u1100', '\x29']), ('\u3201', &['\x28', '\u1102', '\x29']), ('\u3202', &['\x28', '\u1103',
+ '\x29']), ('\u3203', &['\x28', '\u1105', '\x29']), ('\u3204', &['\x28', '\u1106', '\x29']),
+ ('\u3205', &['\x28', '\u1107', '\x29']), ('\u3206', &['\x28', '\u1109', '\x29']), ('\u3207',
+ &['\x28', '\u110b', '\x29']), ('\u3208', &['\x28', '\u110c', '\x29']), ('\u3209', &['\x28',
+ '\u110e', '\x29']), ('\u320a', &['\x28', '\u110f', '\x29']), ('\u320b', &['\x28', '\u1110',
+ '\x29']), ('\u320c', &['\x28', '\u1111', '\x29']), ('\u320d', &['\x28', '\u1112', '\x29']),
+ ('\u320e', &['\x28', '\u1100', '\u1161', '\x29']), ('\u320f', &['\x28', '\u1102', '\u1161',
+ '\x29']), ('\u3210', &['\x28', '\u1103', '\u1161', '\x29']), ('\u3211', &['\x28', '\u1105',
+ '\u1161', '\x29']), ('\u3212', &['\x28', '\u1106', '\u1161', '\x29']), ('\u3213', &['\x28',
+ '\u1107', '\u1161', '\x29']), ('\u3214', &['\x28', '\u1109', '\u1161', '\x29']), ('\u3215',
+ &['\x28', '\u110b', '\u1161', '\x29']), ('\u3216', &['\x28', '\u110c', '\u1161', '\x29']),
+ ('\u3217', &['\x28', '\u110e', '\u1161', '\x29']), ('\u3218', &['\x28', '\u110f', '\u1161',
+ '\x29']), ('\u3219', &['\x28', '\u1110', '\u1161', '\x29']), ('\u321a', &['\x28', '\u1111',
+ '\u1161', '\x29']), ('\u321b', &['\x28', '\u1112', '\u1161', '\x29']), ('\u321c', &['\x28',
+ '\u110c', '\u116e', '\x29']), ('\u321d', &['\x28', '\u110b', '\u1169', '\u110c', '\u1165',
+ '\u11ab', '\x29']), ('\u321e', &['\x28', '\u110b', '\u1169', '\u1112', '\u116e', '\x29']),
+ ('\u3220', &['\x28', '\u4e00', '\x29']), ('\u3221', &['\x28', '\u4e8c', '\x29']), ('\u3222',
+ &['\x28', '\u4e09', '\x29']), ('\u3223', &['\x28', '\u56db', '\x29']), ('\u3224', &['\x28',
+ '\u4e94', '\x29']), ('\u3225', &['\x28', '\u516d', '\x29']), ('\u3226', &['\x28', '\u4e03',
+ '\x29']), ('\u3227', &['\x28', '\u516b', '\x29']), ('\u3228', &['\x28', '\u4e5d', '\x29']),
+ ('\u3229', &['\x28', '\u5341', '\x29']), ('\u322a', &['\x28', '\u6708', '\x29']), ('\u322b',
+ &['\x28', '\u706b', '\x29']), ('\u322c', &['\x28', '\u6c34', '\x29']), ('\u322d', &['\x28',
+ '\u6728', '\x29']), ('\u322e', &['\x28', '\u91d1', '\x29']), ('\u322f', &['\x28', '\u571f',
+ '\x29']), ('\u3230', &['\x28', '\u65e5', '\x29']), ('\u3231', &['\x28', '\u682a', '\x29']),
+ ('\u3232', &['\x28', '\u6709', '\x29']), ('\u3233', &['\x28', '\u793e', '\x29']), ('\u3234',
+ &['\x28', '\u540d', '\x29']), ('\u3235', &['\x28', '\u7279', '\x29']), ('\u3236', &['\x28',
+ '\u8ca1', '\x29']), ('\u3237', &['\x28', '\u795d', '\x29']), ('\u3238', &['\x28', '\u52b4',
+ '\x29']), ('\u3239', &['\x28', '\u4ee3', '\x29']), ('\u323a', &['\x28', '\u547c', '\x29']),
+ ('\u323b', &['\x28', '\u5b66', '\x29']), ('\u323c', &['\x28', '\u76e3', '\x29']), ('\u323d',
+ &['\x28', '\u4f01', '\x29']), ('\u323e', &['\x28', '\u8cc7', '\x29']), ('\u323f', &['\x28',
+ '\u5354', '\x29']), ('\u3240', &['\x28', '\u796d', '\x29']), ('\u3241', &['\x28', '\u4f11',
+ '\x29']), ('\u3242', &['\x28', '\u81ea', '\x29']), ('\u3243', &['\x28', '\u81f3', '\x29']),
+ ('\u3244', &['\u554f']), ('\u3245', &['\u5e7c']), ('\u3246', &['\u6587']), ('\u3247',
+ &['\u7b8f']), ('\u3250', &['\x50', '\x54', '\x45']), ('\u3251', &['\x32', '\x31']),
+ ('\u3252', &['\x32', '\x32']), ('\u3253', &['\x32', '\x33']), ('\u3254', &['\x32', '\x34']),
+ ('\u3255', &['\x32', '\x35']), ('\u3256', &['\x32', '\x36']), ('\u3257', &['\x32', '\x37']),
+ ('\u3258', &['\x32', '\x38']), ('\u3259', &['\x32', '\x39']), ('\u325a', &['\x33', '\x30']),
+ ('\u325b', &['\x33', '\x31']), ('\u325c', &['\x33', '\x32']), ('\u325d', &['\x33', '\x33']),
+ ('\u325e', &['\x33', '\x34']), ('\u325f', &['\x33', '\x35']), ('\u3260', &['\u1100']),
+ ('\u3261', &['\u1102']), ('\u3262', &['\u1103']), ('\u3263', &['\u1105']), ('\u3264',
+ &['\u1106']), ('\u3265', &['\u1107']), ('\u3266', &['\u1109']), ('\u3267', &['\u110b']),
+ ('\u3268', &['\u110c']), ('\u3269', &['\u110e']), ('\u326a', &['\u110f']), ('\u326b',
+ &['\u1110']), ('\u326c', &['\u1111']), ('\u326d', &['\u1112']), ('\u326e', &['\u1100',
+ '\u1161']), ('\u326f', &['\u1102', '\u1161']), ('\u3270', &['\u1103', '\u1161']), ('\u3271',
+ &['\u1105', '\u1161']), ('\u3272', &['\u1106', '\u1161']), ('\u3273', &['\u1107',
+ '\u1161']), ('\u3274', &['\u1109', '\u1161']), ('\u3275', &['\u110b', '\u1161']), ('\u3276',
+ &['\u110c', '\u1161']), ('\u3277', &['\u110e', '\u1161']), ('\u3278', &['\u110f',
+ '\u1161']), ('\u3279', &['\u1110', '\u1161']), ('\u327a', &['\u1111', '\u1161']), ('\u327b',
+ &['\u1112', '\u1161']), ('\u327c', &['\u110e', '\u1161', '\u11b7', '\u1100', '\u1169']),
+ ('\u327d', &['\u110c', '\u116e', '\u110b', '\u1174']), ('\u327e', &['\u110b', '\u116e']),
+ ('\u3280', &['\u4e00']), ('\u3281', &['\u4e8c']), ('\u3282', &['\u4e09']), ('\u3283',
+ &['\u56db']), ('\u3284', &['\u4e94']), ('\u3285', &['\u516d']), ('\u3286', &['\u4e03']),
+ ('\u3287', &['\u516b']), ('\u3288', &['\u4e5d']), ('\u3289', &['\u5341']), ('\u328a',
+ &['\u6708']), ('\u328b', &['\u706b']), ('\u328c', &['\u6c34']), ('\u328d', &['\u6728']),
+ ('\u328e', &['\u91d1']), ('\u328f', &['\u571f']), ('\u3290', &['\u65e5']), ('\u3291',
+ &['\u682a']), ('\u3292', &['\u6709']), ('\u3293', &['\u793e']), ('\u3294', &['\u540d']),
+ ('\u3295', &['\u7279']), ('\u3296', &['\u8ca1']), ('\u3297', &['\u795d']), ('\u3298',
+ &['\u52b4']), ('\u3299', &['\u79d8']), ('\u329a', &['\u7537']), ('\u329b', &['\u5973']),
+ ('\u329c', &['\u9069']), ('\u329d', &['\u512a']), ('\u329e', &['\u5370']), ('\u329f',
+ &['\u6ce8']), ('\u32a0', &['\u9805']), ('\u32a1', &['\u4f11']), ('\u32a2', &['\u5199']),
+ ('\u32a3', &['\u6b63']), ('\u32a4', &['\u4e0a']), ('\u32a5', &['\u4e2d']), ('\u32a6',
+ &['\u4e0b']), ('\u32a7', &['\u5de6']), ('\u32a8', &['\u53f3']), ('\u32a9', &['\u533b']),
+ ('\u32aa', &['\u5b97']), ('\u32ab', &['\u5b66']), ('\u32ac', &['\u76e3']), ('\u32ad',
+ &['\u4f01']), ('\u32ae', &['\u8cc7']), ('\u32af', &['\u5354']), ('\u32b0', &['\u591c']),
+ ('\u32b1', &['\x33', '\x36']), ('\u32b2', &['\x33', '\x37']), ('\u32b3', &['\x33', '\x38']),
+ ('\u32b4', &['\x33', '\x39']), ('\u32b5', &['\x34', '\x30']), ('\u32b6', &['\x34', '\x31']),
+ ('\u32b7', &['\x34', '\x32']), ('\u32b8', &['\x34', '\x33']), ('\u32b9', &['\x34', '\x34']),
+ ('\u32ba', &['\x34', '\x35']), ('\u32bb', &['\x34', '\x36']), ('\u32bc', &['\x34', '\x37']),
+ ('\u32bd', &['\x34', '\x38']), ('\u32be', &['\x34', '\x39']), ('\u32bf', &['\x35', '\x30']),
+ ('\u32c0', &['\x31', '\u6708']), ('\u32c1', &['\x32', '\u6708']), ('\u32c2', &['\x33',
+ '\u6708']), ('\u32c3', &['\x34', '\u6708']), ('\u32c4', &['\x35', '\u6708']), ('\u32c5',
+ &['\x36', '\u6708']), ('\u32c6', &['\x37', '\u6708']), ('\u32c7', &['\x38', '\u6708']),
+ ('\u32c8', &['\x39', '\u6708']), ('\u32c9', &['\x31', '\x30', '\u6708']), ('\u32ca',
+ &['\x31', '\x31', '\u6708']), ('\u32cb', &['\x31', '\x32', '\u6708']), ('\u32cc', &['\x48',
+ '\x67']), ('\u32cd', &['\x65', '\x72', '\x67']), ('\u32ce', &['\x65', '\x56']), ('\u32cf',
+ &['\x4c', '\x54', '\x44']), ('\u32d0', &['\u30a2']), ('\u32d1', &['\u30a4']), ('\u32d2',
+ &['\u30a6']), ('\u32d3', &['\u30a8']), ('\u32d4', &['\u30aa']), ('\u32d5', &['\u30ab']),
+ ('\u32d6', &['\u30ad']), ('\u32d7', &['\u30af']), ('\u32d8', &['\u30b1']), ('\u32d9',
+ &['\u30b3']), ('\u32da', &['\u30b5']), ('\u32db', &['\u30b7']), ('\u32dc', &['\u30b9']),
+ ('\u32dd', &['\u30bb']), ('\u32de', &['\u30bd']), ('\u32df', &['\u30bf']), ('\u32e0',
+ &['\u30c1']), ('\u32e1', &['\u30c4']), ('\u32e2', &['\u30c6']), ('\u32e3', &['\u30c8']),
+ ('\u32e4', &['\u30ca']), ('\u32e5', &['\u30cb']), ('\u32e6', &['\u30cc']), ('\u32e7',
+ &['\u30cd']), ('\u32e8', &['\u30ce']), ('\u32e9', &['\u30cf']), ('\u32ea', &['\u30d2']),
+ ('\u32eb', &['\u30d5']), ('\u32ec', &['\u30d8']), ('\u32ed', &['\u30db']), ('\u32ee',
+ &['\u30de']), ('\u32ef', &['\u30df']), ('\u32f0', &['\u30e0']), ('\u32f1', &['\u30e1']),
+ ('\u32f2', &['\u30e2']), ('\u32f3', &['\u30e4']), ('\u32f4', &['\u30e6']), ('\u32f5',
+ &['\u30e8']), ('\u32f6', &['\u30e9']), ('\u32f7', &['\u30ea']), ('\u32f8', &['\u30eb']),
+ ('\u32f9', &['\u30ec']), ('\u32fa', &['\u30ed']), ('\u32fb', &['\u30ef']), ('\u32fc',
+ &['\u30f0']), ('\u32fd', &['\u30f1']), ('\u32fe', &['\u30f2']), ('\u3300', &['\u30a2',
+ '\u30d1', '\u30fc', '\u30c8']), ('\u3301', &['\u30a2', '\u30eb', '\u30d5', '\u30a1']),
+ ('\u3302', &['\u30a2', '\u30f3', '\u30da', '\u30a2']), ('\u3303', &['\u30a2', '\u30fc',
+ '\u30eb']), ('\u3304', &['\u30a4', '\u30cb', '\u30f3', '\u30b0']), ('\u3305', &['\u30a4',
+ '\u30f3', '\u30c1']), ('\u3306', &['\u30a6', '\u30a9', '\u30f3']), ('\u3307', &['\u30a8',
+ '\u30b9', '\u30af', '\u30fc', '\u30c9']), ('\u3308', &['\u30a8', '\u30fc', '\u30ab',
+ '\u30fc']), ('\u3309', &['\u30aa', '\u30f3', '\u30b9']), ('\u330a', &['\u30aa', '\u30fc',
+ '\u30e0']), ('\u330b', &['\u30ab', '\u30a4', '\u30ea']), ('\u330c', &['\u30ab', '\u30e9',
+ '\u30c3', '\u30c8']), ('\u330d', &['\u30ab', '\u30ed', '\u30ea', '\u30fc']), ('\u330e',
+ &['\u30ac', '\u30ed', '\u30f3']), ('\u330f', &['\u30ac', '\u30f3', '\u30de']), ('\u3310',
+ &['\u30ae', '\u30ac']), ('\u3311', &['\u30ae', '\u30cb', '\u30fc']), ('\u3312', &['\u30ad',
+ '\u30e5', '\u30ea', '\u30fc']), ('\u3313', &['\u30ae', '\u30eb', '\u30c0', '\u30fc']),
+ ('\u3314', &['\u30ad', '\u30ed']), ('\u3315', &['\u30ad', '\u30ed', '\u30b0', '\u30e9',
+ '\u30e0']), ('\u3316', &['\u30ad', '\u30ed', '\u30e1', '\u30fc', '\u30c8', '\u30eb']),
+ ('\u3317', &['\u30ad', '\u30ed', '\u30ef', '\u30c3', '\u30c8']), ('\u3318', &['\u30b0',
+ '\u30e9', '\u30e0']), ('\u3319', &['\u30b0', '\u30e9', '\u30e0', '\u30c8', '\u30f3']),
+ ('\u331a', &['\u30af', '\u30eb', '\u30bc', '\u30a4', '\u30ed']), ('\u331b', &['\u30af',
+ '\u30ed', '\u30fc', '\u30cd']), ('\u331c', &['\u30b1', '\u30fc', '\u30b9']), ('\u331d',
+ &['\u30b3', '\u30eb', '\u30ca']), ('\u331e', &['\u30b3', '\u30fc', '\u30dd']), ('\u331f',
+ &['\u30b5', '\u30a4', '\u30af', '\u30eb']), ('\u3320', &['\u30b5', '\u30f3', '\u30c1',
+ '\u30fc', '\u30e0']), ('\u3321', &['\u30b7', '\u30ea', '\u30f3', '\u30b0']), ('\u3322',
+ &['\u30bb', '\u30f3', '\u30c1']), ('\u3323', &['\u30bb', '\u30f3', '\u30c8']), ('\u3324',
+ &['\u30c0', '\u30fc', '\u30b9']), ('\u3325', &['\u30c7', '\u30b7']), ('\u3326', &['\u30c9',
+ '\u30eb']), ('\u3327', &['\u30c8', '\u30f3']), ('\u3328', &['\u30ca', '\u30ce']), ('\u3329',
+ &['\u30ce', '\u30c3', '\u30c8']), ('\u332a', &['\u30cf', '\u30a4', '\u30c4']), ('\u332b',
+ &['\u30d1', '\u30fc', '\u30bb', '\u30f3', '\u30c8']), ('\u332c', &['\u30d1', '\u30fc',
+ '\u30c4']), ('\u332d', &['\u30d0', '\u30fc', '\u30ec', '\u30eb']), ('\u332e', &['\u30d4',
+ '\u30a2', '\u30b9', '\u30c8', '\u30eb']), ('\u332f', &['\u30d4', '\u30af', '\u30eb']),
+ ('\u3330', &['\u30d4', '\u30b3']), ('\u3331', &['\u30d3', '\u30eb']), ('\u3332', &['\u30d5',
+ '\u30a1', '\u30e9', '\u30c3', '\u30c9']), ('\u3333', &['\u30d5', '\u30a3', '\u30fc',
+ '\u30c8']), ('\u3334', &['\u30d6', '\u30c3', '\u30b7', '\u30a7', '\u30eb']), ('\u3335',
+ &['\u30d5', '\u30e9', '\u30f3']), ('\u3336', &['\u30d8', '\u30af', '\u30bf', '\u30fc',
+ '\u30eb']), ('\u3337', &['\u30da', '\u30bd']), ('\u3338', &['\u30da', '\u30cb', '\u30d2']),
+ ('\u3339', &['\u30d8', '\u30eb', '\u30c4']), ('\u333a', &['\u30da', '\u30f3', '\u30b9']),
+ ('\u333b', &['\u30da', '\u30fc', '\u30b8']), ('\u333c', &['\u30d9', '\u30fc', '\u30bf']),
+ ('\u333d', &['\u30dd', '\u30a4', '\u30f3', '\u30c8']), ('\u333e', &['\u30dc', '\u30eb',
+ '\u30c8']), ('\u333f', &['\u30db', '\u30f3']), ('\u3340', &['\u30dd', '\u30f3', '\u30c9']),
+ ('\u3341', &['\u30db', '\u30fc', '\u30eb']), ('\u3342', &['\u30db', '\u30fc', '\u30f3']),
+ ('\u3343', &['\u30de', '\u30a4', '\u30af', '\u30ed']), ('\u3344', &['\u30de', '\u30a4',
+ '\u30eb']), ('\u3345', &['\u30de', '\u30c3', '\u30cf']), ('\u3346', &['\u30de', '\u30eb',
+ '\u30af']), ('\u3347', &['\u30de', '\u30f3', '\u30b7', '\u30e7', '\u30f3']), ('\u3348',
+ &['\u30df', '\u30af', '\u30ed', '\u30f3']), ('\u3349', &['\u30df', '\u30ea']), ('\u334a',
+ &['\u30df', '\u30ea', '\u30d0', '\u30fc', '\u30eb']), ('\u334b', &['\u30e1', '\u30ac']),
+ ('\u334c', &['\u30e1', '\u30ac', '\u30c8', '\u30f3']), ('\u334d', &['\u30e1', '\u30fc',
+ '\u30c8', '\u30eb']), ('\u334e', &['\u30e4', '\u30fc', '\u30c9']), ('\u334f', &['\u30e4',
+ '\u30fc', '\u30eb']), ('\u3350', &['\u30e6', '\u30a2', '\u30f3']), ('\u3351', &['\u30ea',
+ '\u30c3', '\u30c8', '\u30eb']), ('\u3352', &['\u30ea', '\u30e9']), ('\u3353', &['\u30eb',
+ '\u30d4', '\u30fc']), ('\u3354', &['\u30eb', '\u30fc', '\u30d6', '\u30eb']), ('\u3355',
+ &['\u30ec', '\u30e0']), ('\u3356', &['\u30ec', '\u30f3', '\u30c8', '\u30b2', '\u30f3']),
+ ('\u3357', &['\u30ef', '\u30c3', '\u30c8']), ('\u3358', &['\x30', '\u70b9']), ('\u3359',
+ &['\x31', '\u70b9']), ('\u335a', &['\x32', '\u70b9']), ('\u335b', &['\x33', '\u70b9']),
+ ('\u335c', &['\x34', '\u70b9']), ('\u335d', &['\x35', '\u70b9']), ('\u335e', &['\x36',
+ '\u70b9']), ('\u335f', &['\x37', '\u70b9']), ('\u3360', &['\x38', '\u70b9']), ('\u3361',
+ &['\x39', '\u70b9']), ('\u3362', &['\x31', '\x30', '\u70b9']), ('\u3363', &['\x31', '\x31',
+ '\u70b9']), ('\u3364', &['\x31', '\x32', '\u70b9']), ('\u3365', &['\x31', '\x33',
+ '\u70b9']), ('\u3366', &['\x31', '\x34', '\u70b9']), ('\u3367', &['\x31', '\x35',
+ '\u70b9']), ('\u3368', &['\x31', '\x36', '\u70b9']), ('\u3369', &['\x31', '\x37',
+ '\u70b9']), ('\u336a', &['\x31', '\x38', '\u70b9']), ('\u336b', &['\x31', '\x39',
+ '\u70b9']), ('\u336c', &['\x32', '\x30', '\u70b9']), ('\u336d', &['\x32', '\x31',
+ '\u70b9']), ('\u336e', &['\x32', '\x32', '\u70b9']), ('\u336f', &['\x32', '\x33',
+ '\u70b9']), ('\u3370', &['\x32', '\x34', '\u70b9']), ('\u3371', &['\x68', '\x50', '\x61']),
+ ('\u3372', &['\x64', '\x61']), ('\u3373', &['\x41', '\x55']), ('\u3374', &['\x62', '\x61',
+ '\x72']), ('\u3375', &['\x6f', '\x56']), ('\u3376', &['\x70', '\x63']), ('\u3377', &['\x64',
+ '\x6d']), ('\u3378', &['\x64', '\x6d', '\xb2']), ('\u3379', &['\x64', '\x6d', '\xb3']),
+ ('\u337a', &['\x49', '\x55']), ('\u337b', &['\u5e73', '\u6210']), ('\u337c', &['\u662d',
+ '\u548c']), ('\u337d', &['\u5927', '\u6b63']), ('\u337e', &['\u660e', '\u6cbb']), ('\u337f',
+ &['\u682a', '\u5f0f', '\u4f1a', '\u793e']), ('\u3380', &['\x70', '\x41']), ('\u3381',
+ &['\x6e', '\x41']), ('\u3382', &['\u03bc', '\x41']), ('\u3383', &['\x6d', '\x41']),
+ ('\u3384', &['\x6b', '\x41']), ('\u3385', &['\x4b', '\x42']), ('\u3386', &['\x4d', '\x42']),
+ ('\u3387', &['\x47', '\x42']), ('\u3388', &['\x63', '\x61', '\x6c']), ('\u3389', &['\x6b',
+ '\x63', '\x61', '\x6c']), ('\u338a', &['\x70', '\x46']), ('\u338b', &['\x6e', '\x46']),
+ ('\u338c', &['\u03bc', '\x46']), ('\u338d', &['\u03bc', '\x67']), ('\u338e', &['\x6d',
+ '\x67']), ('\u338f', &['\x6b', '\x67']), ('\u3390', &['\x48', '\x7a']), ('\u3391', &['\x6b',
+ '\x48', '\x7a']), ('\u3392', &['\x4d', '\x48', '\x7a']), ('\u3393', &['\x47', '\x48',
+ '\x7a']), ('\u3394', &['\x54', '\x48', '\x7a']), ('\u3395', &['\u03bc', '\u2113']),
+ ('\u3396', &['\x6d', '\u2113']), ('\u3397', &['\x64', '\u2113']), ('\u3398', &['\x6b',
+ '\u2113']), ('\u3399', &['\x66', '\x6d']), ('\u339a', &['\x6e', '\x6d']), ('\u339b',
+ &['\u03bc', '\x6d']), ('\u339c', &['\x6d', '\x6d']), ('\u339d', &['\x63', '\x6d']),
+ ('\u339e', &['\x6b', '\x6d']), ('\u339f', &['\x6d', '\x6d', '\xb2']), ('\u33a0', &['\x63',
+ '\x6d', '\xb2']), ('\u33a1', &['\x6d', '\xb2']), ('\u33a2', &['\x6b', '\x6d', '\xb2']),
+ ('\u33a3', &['\x6d', '\x6d', '\xb3']), ('\u33a4', &['\x63', '\x6d', '\xb3']), ('\u33a5',
+ &['\x6d', '\xb3']), ('\u33a6', &['\x6b', '\x6d', '\xb3']), ('\u33a7', &['\x6d', '\u2215',
+ '\x73']), ('\u33a8', &['\x6d', '\u2215', '\x73', '\xb2']), ('\u33a9', &['\x50', '\x61']),
+ ('\u33aa', &['\x6b', '\x50', '\x61']), ('\u33ab', &['\x4d', '\x50', '\x61']), ('\u33ac',
+ &['\x47', '\x50', '\x61']), ('\u33ad', &['\x72', '\x61', '\x64']), ('\u33ae', &['\x72',
+ '\x61', '\x64', '\u2215', '\x73']), ('\u33af', &['\x72', '\x61', '\x64', '\u2215', '\x73',
+ '\xb2']), ('\u33b0', &['\x70', '\x73']), ('\u33b1', &['\x6e', '\x73']), ('\u33b2',
+ &['\u03bc', '\x73']), ('\u33b3', &['\x6d', '\x73']), ('\u33b4', &['\x70', '\x56']),
+ ('\u33b5', &['\x6e', '\x56']), ('\u33b6', &['\u03bc', '\x56']), ('\u33b7', &['\x6d',
+ '\x56']), ('\u33b8', &['\x6b', '\x56']), ('\u33b9', &['\x4d', '\x56']), ('\u33ba', &['\x70',
+ '\x57']), ('\u33bb', &['\x6e', '\x57']), ('\u33bc', &['\u03bc', '\x57']), ('\u33bd',
+ &['\x6d', '\x57']), ('\u33be', &['\x6b', '\x57']), ('\u33bf', &['\x4d', '\x57']), ('\u33c0',
+ &['\x6b', '\u03a9']), ('\u33c1', &['\x4d', '\u03a9']), ('\u33c2', &['\x61', '\x2e', '\x6d',
+ '\x2e']), ('\u33c3', &['\x42', '\x71']), ('\u33c4', &['\x63', '\x63']), ('\u33c5', &['\x63',
+ '\x64']), ('\u33c6', &['\x43', '\u2215', '\x6b', '\x67']), ('\u33c7', &['\x43', '\x6f',
+ '\x2e']), ('\u33c8', &['\x64', '\x42']), ('\u33c9', &['\x47', '\x79']), ('\u33ca', &['\x68',
+ '\x61']), ('\u33cb', &['\x48', '\x50']), ('\u33cc', &['\x69', '\x6e']), ('\u33cd', &['\x4b',
+ '\x4b']), ('\u33ce', &['\x4b', '\x4d']), ('\u33cf', &['\x6b', '\x74']), ('\u33d0', &['\x6c',
+ '\x6d']), ('\u33d1', &['\x6c', '\x6e']), ('\u33d2', &['\x6c', '\x6f', '\x67']), ('\u33d3',
+ &['\x6c', '\x78']), ('\u33d4', &['\x6d', '\x62']), ('\u33d5', &['\x6d', '\x69', '\x6c']),
+ ('\u33d6', &['\x6d', '\x6f', '\x6c']), ('\u33d7', &['\x50', '\x48']), ('\u33d8', &['\x70',
+ '\x2e', '\x6d', '\x2e']), ('\u33d9', &['\x50', '\x50', '\x4d']), ('\u33da', &['\x50',
+ '\x52']), ('\u33db', &['\x73', '\x72']), ('\u33dc', &['\x53', '\x76']), ('\u33dd', &['\x57',
+ '\x62']), ('\u33de', &['\x56', '\u2215', '\x6d']), ('\u33df', &['\x41', '\u2215', '\x6d']),
+ ('\u33e0', &['\x31', '\u65e5']), ('\u33e1', &['\x32', '\u65e5']), ('\u33e2', &['\x33',
+ '\u65e5']), ('\u33e3', &['\x34', '\u65e5']), ('\u33e4', &['\x35', '\u65e5']), ('\u33e5',
+ &['\x36', '\u65e5']), ('\u33e6', &['\x37', '\u65e5']), ('\u33e7', &['\x38', '\u65e5']),
+ ('\u33e8', &['\x39', '\u65e5']), ('\u33e9', &['\x31', '\x30', '\u65e5']), ('\u33ea',
+ &['\x31', '\x31', '\u65e5']), ('\u33eb', &['\x31', '\x32', '\u65e5']), ('\u33ec', &['\x31',
+ '\x33', '\u65e5']), ('\u33ed', &['\x31', '\x34', '\u65e5']), ('\u33ee', &['\x31', '\x35',
+ '\u65e5']), ('\u33ef', &['\x31', '\x36', '\u65e5']), ('\u33f0', &['\x31', '\x37',
+ '\u65e5']), ('\u33f1', &['\x31', '\x38', '\u65e5']), ('\u33f2', &['\x31', '\x39',
+ '\u65e5']), ('\u33f3', &['\x32', '\x30', '\u65e5']), ('\u33f4', &['\x32', '\x31',
+ '\u65e5']), ('\u33f5', &['\x32', '\x32', '\u65e5']), ('\u33f6', &['\x32', '\x33',
+ '\u65e5']), ('\u33f7', &['\x32', '\x34', '\u65e5']), ('\u33f8', &['\x32', '\x35',
+ '\u65e5']), ('\u33f9', &['\x32', '\x36', '\u65e5']), ('\u33fa', &['\x32', '\x37',
+ '\u65e5']), ('\u33fb', &['\x32', '\x38', '\u65e5']), ('\u33fc', &['\x32', '\x39',
+ '\u65e5']), ('\u33fd', &['\x33', '\x30', '\u65e5']), ('\u33fe', &['\x33', '\x31',
+ '\u65e5']), ('\u33ff', &['\x67', '\x61', '\x6c']), ('\ua69c', &['\u044a']), ('\ua69d',
+ &['\u044c']), ('\ua770', &['\ua76f']), ('\ua7f8', &['\u0126']), ('\ua7f9', &['\u0153']),
+ ('\uab5c', &['\ua727']), ('\uab5d', &['\uab37']), ('\uab5e', &['\u026b']), ('\uab5f',
+ &['\uab52']), ('\ufb00', &['\x66', '\x66']), ('\ufb01', &['\x66', '\x69']), ('\ufb02',
+ &['\x66', '\x6c']), ('\ufb03', &['\x66', '\x66', '\x69']), ('\ufb04', &['\x66', '\x66',
+ '\x6c']), ('\ufb05', &['\u017f', '\x74']), ('\ufb06', &['\x73', '\x74']), ('\ufb13',
+ &['\u0574', '\u0576']), ('\ufb14', &['\u0574', '\u0565']), ('\ufb15', &['\u0574',
+ '\u056b']), ('\ufb16', &['\u057e', '\u0576']), ('\ufb17', &['\u0574', '\u056d']), ('\ufb20',
+ &['\u05e2']), ('\ufb21', &['\u05d0']), ('\ufb22', &['\u05d3']), ('\ufb23', &['\u05d4']),
+ ('\ufb24', &['\u05db']), ('\ufb25', &['\u05dc']), ('\ufb26', &['\u05dd']), ('\ufb27',
+ &['\u05e8']), ('\ufb28', &['\u05ea']), ('\ufb29', &['\x2b']), ('\ufb4f', &['\u05d0',
+ '\u05dc']), ('\ufb50', &['\u0671']), ('\ufb51', &['\u0671']), ('\ufb52', &['\u067b']),
+ ('\ufb53', &['\u067b']), ('\ufb54', &['\u067b']), ('\ufb55', &['\u067b']), ('\ufb56',
+ &['\u067e']), ('\ufb57', &['\u067e']), ('\ufb58', &['\u067e']), ('\ufb59', &['\u067e']),
+ ('\ufb5a', &['\u0680']), ('\ufb5b', &['\u0680']), ('\ufb5c', &['\u0680']), ('\ufb5d',
+ &['\u0680']), ('\ufb5e', &['\u067a']), ('\ufb5f', &['\u067a']), ('\ufb60', &['\u067a']),
+ ('\ufb61', &['\u067a']), ('\ufb62', &['\u067f']), ('\ufb63', &['\u067f']), ('\ufb64',
+ &['\u067f']), ('\ufb65', &['\u067f']), ('\ufb66', &['\u0679']), ('\ufb67', &['\u0679']),
+ ('\ufb68', &['\u0679']), ('\ufb69', &['\u0679']), ('\ufb6a', &['\u06a4']), ('\ufb6b',
+ &['\u06a4']), ('\ufb6c', &['\u06a4']), ('\ufb6d', &['\u06a4']), ('\ufb6e', &['\u06a6']),
+ ('\ufb6f', &['\u06a6']), ('\ufb70', &['\u06a6']), ('\ufb71', &['\u06a6']), ('\ufb72',
+ &['\u0684']), ('\ufb73', &['\u0684']), ('\ufb74', &['\u0684']), ('\ufb75', &['\u0684']),
+ ('\ufb76', &['\u0683']), ('\ufb77', &['\u0683']), ('\ufb78', &['\u0683']), ('\ufb79',
+ &['\u0683']), ('\ufb7a', &['\u0686']), ('\ufb7b', &['\u0686']), ('\ufb7c', &['\u0686']),
+ ('\ufb7d', &['\u0686']), ('\ufb7e', &['\u0687']), ('\ufb7f', &['\u0687']), ('\ufb80',
+ &['\u0687']), ('\ufb81', &['\u0687']), ('\ufb82', &['\u068d']), ('\ufb83', &['\u068d']),
+ ('\ufb84', &['\u068c']), ('\ufb85', &['\u068c']), ('\ufb86', &['\u068e']), ('\ufb87',
+ &['\u068e']), ('\ufb88', &['\u0688']), ('\ufb89', &['\u0688']), ('\ufb8a', &['\u0698']),
+ ('\ufb8b', &['\u0698']), ('\ufb8c', &['\u0691']), ('\ufb8d', &['\u0691']), ('\ufb8e',
+ &['\u06a9']), ('\ufb8f', &['\u06a9']), ('\ufb90', &['\u06a9']), ('\ufb91', &['\u06a9']),
+ ('\ufb92', &['\u06af']), ('\ufb93', &['\u06af']), ('\ufb94', &['\u06af']), ('\ufb95',
+ &['\u06af']), ('\ufb96', &['\u06b3']), ('\ufb97', &['\u06b3']), ('\ufb98', &['\u06b3']),
+ ('\ufb99', &['\u06b3']), ('\ufb9a', &['\u06b1']), ('\ufb9b', &['\u06b1']), ('\ufb9c',
+ &['\u06b1']), ('\ufb9d', &['\u06b1']), ('\ufb9e', &['\u06ba']), ('\ufb9f', &['\u06ba']),
+ ('\ufba0', &['\u06bb']), ('\ufba1', &['\u06bb']), ('\ufba2', &['\u06bb']), ('\ufba3',
+ &['\u06bb']), ('\ufba4', &['\u06c0']), ('\ufba5', &['\u06c0']), ('\ufba6', &['\u06c1']),
+ ('\ufba7', &['\u06c1']), ('\ufba8', &['\u06c1']), ('\ufba9', &['\u06c1']), ('\ufbaa',
+ &['\u06be']), ('\ufbab', &['\u06be']), ('\ufbac', &['\u06be']), ('\ufbad', &['\u06be']),
+ ('\ufbae', &['\u06d2']), ('\ufbaf', &['\u06d2']), ('\ufbb0', &['\u06d3']), ('\ufbb1',
+ &['\u06d3']), ('\ufbd3', &['\u06ad']), ('\ufbd4', &['\u06ad']), ('\ufbd5', &['\u06ad']),
+ ('\ufbd6', &['\u06ad']), ('\ufbd7', &['\u06c7']), ('\ufbd8', &['\u06c7']), ('\ufbd9',
+ &['\u06c6']), ('\ufbda', &['\u06c6']), ('\ufbdb', &['\u06c8']), ('\ufbdc', &['\u06c8']),
+ ('\ufbdd', &['\u0677']), ('\ufbde', &['\u06cb']), ('\ufbdf', &['\u06cb']), ('\ufbe0',
+ &['\u06c5']), ('\ufbe1', &['\u06c5']), ('\ufbe2', &['\u06c9']), ('\ufbe3', &['\u06c9']),
+ ('\ufbe4', &['\u06d0']), ('\ufbe5', &['\u06d0']), ('\ufbe6', &['\u06d0']), ('\ufbe7',
+ &['\u06d0']), ('\ufbe8', &['\u0649']), ('\ufbe9', &['\u0649']), ('\ufbea', &['\u0626',
+ '\u0627']), ('\ufbeb', &['\u0626', '\u0627']), ('\ufbec', &['\u0626', '\u06d5']), ('\ufbed',
+ &['\u0626', '\u06d5']), ('\ufbee', &['\u0626', '\u0648']), ('\ufbef', &['\u0626',
+ '\u0648']), ('\ufbf0', &['\u0626', '\u06c7']), ('\ufbf1', &['\u0626', '\u06c7']), ('\ufbf2',
+ &['\u0626', '\u06c6']), ('\ufbf3', &['\u0626', '\u06c6']), ('\ufbf4', &['\u0626',
+ '\u06c8']), ('\ufbf5', &['\u0626', '\u06c8']), ('\ufbf6', &['\u0626', '\u06d0']), ('\ufbf7',
+ &['\u0626', '\u06d0']), ('\ufbf8', &['\u0626', '\u06d0']), ('\ufbf9', &['\u0626',
+ '\u0649']), ('\ufbfa', &['\u0626', '\u0649']), ('\ufbfb', &['\u0626', '\u0649']), ('\ufbfc',
+ &['\u06cc']), ('\ufbfd', &['\u06cc']), ('\ufbfe', &['\u06cc']), ('\ufbff', &['\u06cc']),
+ ('\ufc00', &['\u0626', '\u062c']), ('\ufc01', &['\u0626', '\u062d']), ('\ufc02', &['\u0626',
+ '\u0645']), ('\ufc03', &['\u0626', '\u0649']), ('\ufc04', &['\u0626', '\u064a']), ('\ufc05',
+ &['\u0628', '\u062c']), ('\ufc06', &['\u0628', '\u062d']), ('\ufc07', &['\u0628',
+ '\u062e']), ('\ufc08', &['\u0628', '\u0645']), ('\ufc09', &['\u0628', '\u0649']), ('\ufc0a',
+ &['\u0628', '\u064a']), ('\ufc0b', &['\u062a', '\u062c']), ('\ufc0c', &['\u062a',
+ '\u062d']), ('\ufc0d', &['\u062a', '\u062e']), ('\ufc0e', &['\u062a', '\u0645']), ('\ufc0f',
+ &['\u062a', '\u0649']), ('\ufc10', &['\u062a', '\u064a']), ('\ufc11', &['\u062b',
+ '\u062c']), ('\ufc12', &['\u062b', '\u0645']), ('\ufc13', &['\u062b', '\u0649']), ('\ufc14',
+ &['\u062b', '\u064a']), ('\ufc15', &['\u062c', '\u062d']), ('\ufc16', &['\u062c',
+ '\u0645']), ('\ufc17', &['\u062d', '\u062c']), ('\ufc18', &['\u062d', '\u0645']), ('\ufc19',
+ &['\u062e', '\u062c']), ('\ufc1a', &['\u062e', '\u062d']), ('\ufc1b', &['\u062e',
+ '\u0645']), ('\ufc1c', &['\u0633', '\u062c']), ('\ufc1d', &['\u0633', '\u062d']), ('\ufc1e',
+ &['\u0633', '\u062e']), ('\ufc1f', &['\u0633', '\u0645']), ('\ufc20', &['\u0635',
+ '\u062d']), ('\ufc21', &['\u0635', '\u0645']), ('\ufc22', &['\u0636', '\u062c']), ('\ufc23',
+ &['\u0636', '\u062d']), ('\ufc24', &['\u0636', '\u062e']), ('\ufc25', &['\u0636',
+ '\u0645']), ('\ufc26', &['\u0637', '\u062d']), ('\ufc27', &['\u0637', '\u0645']), ('\ufc28',
+ &['\u0638', '\u0645']), ('\ufc29', &['\u0639', '\u062c']), ('\ufc2a', &['\u0639',
+ '\u0645']), ('\ufc2b', &['\u063a', '\u062c']), ('\ufc2c', &['\u063a', '\u0645']), ('\ufc2d',
+ &['\u0641', '\u062c']), ('\ufc2e', &['\u0641', '\u062d']), ('\ufc2f', &['\u0641',
+ '\u062e']), ('\ufc30', &['\u0641', '\u0645']), ('\ufc31', &['\u0641', '\u0649']), ('\ufc32',
+ &['\u0641', '\u064a']), ('\ufc33', &['\u0642', '\u062d']), ('\ufc34', &['\u0642',
+ '\u0645']), ('\ufc35', &['\u0642', '\u0649']), ('\ufc36', &['\u0642', '\u064a']), ('\ufc37',
+ &['\u0643', '\u0627']), ('\ufc38', &['\u0643', '\u062c']), ('\ufc39', &['\u0643',
+ '\u062d']), ('\ufc3a', &['\u0643', '\u062e']), ('\ufc3b', &['\u0643', '\u0644']), ('\ufc3c',
+ &['\u0643', '\u0645']), ('\ufc3d', &['\u0643', '\u0649']), ('\ufc3e', &['\u0643',
+ '\u064a']), ('\ufc3f', &['\u0644', '\u062c']), ('\ufc40', &['\u0644', '\u062d']), ('\ufc41',
+ &['\u0644', '\u062e']), ('\ufc42', &['\u0644', '\u0645']), ('\ufc43', &['\u0644',
+ '\u0649']), ('\ufc44', &['\u0644', '\u064a']), ('\ufc45', &['\u0645', '\u062c']), ('\ufc46',
+ &['\u0645', '\u062d']), ('\ufc47', &['\u0645', '\u062e']), ('\ufc48', &['\u0645',
+ '\u0645']), ('\ufc49', &['\u0645', '\u0649']), ('\ufc4a', &['\u0645', '\u064a']), ('\ufc4b',
+ &['\u0646', '\u062c']), ('\ufc4c', &['\u0646', '\u062d']), ('\ufc4d', &['\u0646',
+ '\u062e']), ('\ufc4e', &['\u0646', '\u0645']), ('\ufc4f', &['\u0646', '\u0649']), ('\ufc50',
+ &['\u0646', '\u064a']), ('\ufc51', &['\u0647', '\u062c']), ('\ufc52', &['\u0647',
+ '\u0645']), ('\ufc53', &['\u0647', '\u0649']), ('\ufc54', &['\u0647', '\u064a']), ('\ufc55',
+ &['\u064a', '\u062c']), ('\ufc56', &['\u064a', '\u062d']), ('\ufc57', &['\u064a',
+ '\u062e']), ('\ufc58', &['\u064a', '\u0645']), ('\ufc59', &['\u064a', '\u0649']), ('\ufc5a',
+ &['\u064a', '\u064a']), ('\ufc5b', &['\u0630', '\u0670']), ('\ufc5c', &['\u0631',
+ '\u0670']), ('\ufc5d', &['\u0649', '\u0670']), ('\ufc5e', &['\x20', '\u064c', '\u0651']),
+ ('\ufc5f', &['\x20', '\u064d', '\u0651']), ('\ufc60', &['\x20', '\u064e', '\u0651']),
+ ('\ufc61', &['\x20', '\u064f', '\u0651']), ('\ufc62', &['\x20', '\u0650', '\u0651']),
+ ('\ufc63', &['\x20', '\u0651', '\u0670']), ('\ufc64', &['\u0626', '\u0631']), ('\ufc65',
+ &['\u0626', '\u0632']), ('\ufc66', &['\u0626', '\u0645']), ('\ufc67', &['\u0626',
+ '\u0646']), ('\ufc68', &['\u0626', '\u0649']), ('\ufc69', &['\u0626', '\u064a']), ('\ufc6a',
+ &['\u0628', '\u0631']), ('\ufc6b', &['\u0628', '\u0632']), ('\ufc6c', &['\u0628',
+ '\u0645']), ('\ufc6d', &['\u0628', '\u0646']), ('\ufc6e', &['\u0628', '\u0649']), ('\ufc6f',
+ &['\u0628', '\u064a']), ('\ufc70', &['\u062a', '\u0631']), ('\ufc71', &['\u062a',
+ '\u0632']), ('\ufc72', &['\u062a', '\u0645']), ('\ufc73', &['\u062a', '\u0646']), ('\ufc74',
+ &['\u062a', '\u0649']), ('\ufc75', &['\u062a', '\u064a']), ('\ufc76', &['\u062b',
+ '\u0631']), ('\ufc77', &['\u062b', '\u0632']), ('\ufc78', &['\u062b', '\u0645']), ('\ufc79',
+ &['\u062b', '\u0646']), ('\ufc7a', &['\u062b', '\u0649']), ('\ufc7b', &['\u062b',
+ '\u064a']), ('\ufc7c', &['\u0641', '\u0649']), ('\ufc7d', &['\u0641', '\u064a']), ('\ufc7e',
+ &['\u0642', '\u0649']), ('\ufc7f', &['\u0642', '\u064a']), ('\ufc80', &['\u0643',
+ '\u0627']), ('\ufc81', &['\u0643', '\u0644']), ('\ufc82', &['\u0643', '\u0645']), ('\ufc83',
+ &['\u0643', '\u0649']), ('\ufc84', &['\u0643', '\u064a']), ('\ufc85', &['\u0644',
+ '\u0645']), ('\ufc86', &['\u0644', '\u0649']), ('\ufc87', &['\u0644', '\u064a']), ('\ufc88',
+ &['\u0645', '\u0627']), ('\ufc89', &['\u0645', '\u0645']), ('\ufc8a', &['\u0646',
+ '\u0631']), ('\ufc8b', &['\u0646', '\u0632']), ('\ufc8c', &['\u0646', '\u0645']), ('\ufc8d',
+ &['\u0646', '\u0646']), ('\ufc8e', &['\u0646', '\u0649']), ('\ufc8f', &['\u0646',
+ '\u064a']), ('\ufc90', &['\u0649', '\u0670']), ('\ufc91', &['\u064a', '\u0631']), ('\ufc92',
+ &['\u064a', '\u0632']), ('\ufc93', &['\u064a', '\u0645']), ('\ufc94', &['\u064a',
+ '\u0646']), ('\ufc95', &['\u064a', '\u0649']), ('\ufc96', &['\u064a', '\u064a']), ('\ufc97',
+ &['\u0626', '\u062c']), ('\ufc98', &['\u0626', '\u062d']), ('\ufc99', &['\u0626',
+ '\u062e']), ('\ufc9a', &['\u0626', '\u0645']), ('\ufc9b', &['\u0626', '\u0647']), ('\ufc9c',
+ &['\u0628', '\u062c']), ('\ufc9d', &['\u0628', '\u062d']), ('\ufc9e', &['\u0628',
+ '\u062e']), ('\ufc9f', &['\u0628', '\u0645']), ('\ufca0', &['\u0628', '\u0647']), ('\ufca1',
+ &['\u062a', '\u062c']), ('\ufca2', &['\u062a', '\u062d']), ('\ufca3', &['\u062a',
+ '\u062e']), ('\ufca4', &['\u062a', '\u0645']), ('\ufca5', &['\u062a', '\u0647']), ('\ufca6',
+ &['\u062b', '\u0645']), ('\ufca7', &['\u062c', '\u062d']), ('\ufca8', &['\u062c',
+ '\u0645']), ('\ufca9', &['\u062d', '\u062c']), ('\ufcaa', &['\u062d', '\u0645']), ('\ufcab',
+ &['\u062e', '\u062c']), ('\ufcac', &['\u062e', '\u0645']), ('\ufcad', &['\u0633',
+ '\u062c']), ('\ufcae', &['\u0633', '\u062d']), ('\ufcaf', &['\u0633', '\u062e']), ('\ufcb0',
+ &['\u0633', '\u0645']), ('\ufcb1', &['\u0635', '\u062d']), ('\ufcb2', &['\u0635',
+ '\u062e']), ('\ufcb3', &['\u0635', '\u0645']), ('\ufcb4', &['\u0636', '\u062c']), ('\ufcb5',
+ &['\u0636', '\u062d']), ('\ufcb6', &['\u0636', '\u062e']), ('\ufcb7', &['\u0636',
+ '\u0645']), ('\ufcb8', &['\u0637', '\u062d']), ('\ufcb9', &['\u0638', '\u0645']), ('\ufcba',
+ &['\u0639', '\u062c']), ('\ufcbb', &['\u0639', '\u0645']), ('\ufcbc', &['\u063a',
+ '\u062c']), ('\ufcbd', &['\u063a', '\u0645']), ('\ufcbe', &['\u0641', '\u062c']), ('\ufcbf',
+ &['\u0641', '\u062d']), ('\ufcc0', &['\u0641', '\u062e']), ('\ufcc1', &['\u0641',
+ '\u0645']), ('\ufcc2', &['\u0642', '\u062d']), ('\ufcc3', &['\u0642', '\u0645']), ('\ufcc4',
+ &['\u0643', '\u062c']), ('\ufcc5', &['\u0643', '\u062d']), ('\ufcc6', &['\u0643',
+ '\u062e']), ('\ufcc7', &['\u0643', '\u0644']), ('\ufcc8', &['\u0643', '\u0645']), ('\ufcc9',
+ &['\u0644', '\u062c']), ('\ufcca', &['\u0644', '\u062d']), ('\ufccb', &['\u0644',
+ '\u062e']), ('\ufccc', &['\u0644', '\u0645']), ('\ufccd', &['\u0644', '\u0647']), ('\ufcce',
+ &['\u0645', '\u062c']), ('\ufccf', &['\u0645', '\u062d']), ('\ufcd0', &['\u0645',
+ '\u062e']), ('\ufcd1', &['\u0645', '\u0645']), ('\ufcd2', &['\u0646', '\u062c']), ('\ufcd3',
+ &['\u0646', '\u062d']), ('\ufcd4', &['\u0646', '\u062e']), ('\ufcd5', &['\u0646',
+ '\u0645']), ('\ufcd6', &['\u0646', '\u0647']), ('\ufcd7', &['\u0647', '\u062c']), ('\ufcd8',
+ &['\u0647', '\u0645']), ('\ufcd9', &['\u0647', '\u0670']), ('\ufcda', &['\u064a',
+ '\u062c']), ('\ufcdb', &['\u064a', '\u062d']), ('\ufcdc', &['\u064a', '\u062e']), ('\ufcdd',
+ &['\u064a', '\u0645']), ('\ufcde', &['\u064a', '\u0647']), ('\ufcdf', &['\u0626',
+ '\u0645']), ('\ufce0', &['\u0626', '\u0647']), ('\ufce1', &['\u0628', '\u0645']), ('\ufce2',
+ &['\u0628', '\u0647']), ('\ufce3', &['\u062a', '\u0645']), ('\ufce4', &['\u062a',
+ '\u0647']), ('\ufce5', &['\u062b', '\u0645']), ('\ufce6', &['\u062b', '\u0647']), ('\ufce7',
+ &['\u0633', '\u0645']), ('\ufce8', &['\u0633', '\u0647']), ('\ufce9', &['\u0634',
+ '\u0645']), ('\ufcea', &['\u0634', '\u0647']), ('\ufceb', &['\u0643', '\u0644']), ('\ufcec',
+ &['\u0643', '\u0645']), ('\ufced', &['\u0644', '\u0645']), ('\ufcee', &['\u0646',
+ '\u0645']), ('\ufcef', &['\u0646', '\u0647']), ('\ufcf0', &['\u064a', '\u0645']), ('\ufcf1',
+ &['\u064a', '\u0647']), ('\ufcf2', &['\u0640', '\u064e', '\u0651']), ('\ufcf3', &['\u0640',
+ '\u064f', '\u0651']), ('\ufcf4', &['\u0640', '\u0650', '\u0651']), ('\ufcf5', &['\u0637',
+ '\u0649']), ('\ufcf6', &['\u0637', '\u064a']), ('\ufcf7', &['\u0639', '\u0649']), ('\ufcf8',
+ &['\u0639', '\u064a']), ('\ufcf9', &['\u063a', '\u0649']), ('\ufcfa', &['\u063a',
+ '\u064a']), ('\ufcfb', &['\u0633', '\u0649']), ('\ufcfc', &['\u0633', '\u064a']), ('\ufcfd',
+ &['\u0634', '\u0649']), ('\ufcfe', &['\u0634', '\u064a']), ('\ufcff', &['\u062d',
+ '\u0649']), ('\ufd00', &['\u062d', '\u064a']), ('\ufd01', &['\u062c', '\u0649']), ('\ufd02',
+ &['\u062c', '\u064a']), ('\ufd03', &['\u062e', '\u0649']), ('\ufd04', &['\u062e',
+ '\u064a']), ('\ufd05', &['\u0635', '\u0649']), ('\ufd06', &['\u0635', '\u064a']), ('\ufd07',
+ &['\u0636', '\u0649']), ('\ufd08', &['\u0636', '\u064a']), ('\ufd09', &['\u0634',
+ '\u062c']), ('\ufd0a', &['\u0634', '\u062d']), ('\ufd0b', &['\u0634', '\u062e']), ('\ufd0c',
+ &['\u0634', '\u0645']), ('\ufd0d', &['\u0634', '\u0631']), ('\ufd0e', &['\u0633',
+ '\u0631']), ('\ufd0f', &['\u0635', '\u0631']), ('\ufd10', &['\u0636', '\u0631']), ('\ufd11',
+ &['\u0637', '\u0649']), ('\ufd12', &['\u0637', '\u064a']), ('\ufd13', &['\u0639',
+ '\u0649']), ('\ufd14', &['\u0639', '\u064a']), ('\ufd15', &['\u063a', '\u0649']), ('\ufd16',
+ &['\u063a', '\u064a']), ('\ufd17', &['\u0633', '\u0649']), ('\ufd18', &['\u0633',
+ '\u064a']), ('\ufd19', &['\u0634', '\u0649']), ('\ufd1a', &['\u0634', '\u064a']), ('\ufd1b',
+ &['\u062d', '\u0649']), ('\ufd1c', &['\u062d', '\u064a']), ('\ufd1d', &['\u062c',
+ '\u0649']), ('\ufd1e', &['\u062c', '\u064a']), ('\ufd1f', &['\u062e', '\u0649']), ('\ufd20',
+ &['\u062e', '\u064a']), ('\ufd21', &['\u0635', '\u0649']), ('\ufd22', &['\u0635',
+ '\u064a']), ('\ufd23', &['\u0636', '\u0649']), ('\ufd24', &['\u0636', '\u064a']), ('\ufd25',
+ &['\u0634', '\u062c']), ('\ufd26', &['\u0634', '\u062d']), ('\ufd27', &['\u0634',
+ '\u062e']), ('\ufd28', &['\u0634', '\u0645']), ('\ufd29', &['\u0634', '\u0631']), ('\ufd2a',
+ &['\u0633', '\u0631']), ('\ufd2b', &['\u0635', '\u0631']), ('\ufd2c', &['\u0636',
+ '\u0631']), ('\ufd2d', &['\u0634', '\u062c']), ('\ufd2e', &['\u0634', '\u062d']), ('\ufd2f',
+ &['\u0634', '\u062e']), ('\ufd30', &['\u0634', '\u0645']), ('\ufd31', &['\u0633',
+ '\u0647']), ('\ufd32', &['\u0634', '\u0647']), ('\ufd33', &['\u0637', '\u0645']), ('\ufd34',
+ &['\u0633', '\u062c']), ('\ufd35', &['\u0633', '\u062d']), ('\ufd36', &['\u0633',
+ '\u062e']), ('\ufd37', &['\u0634', '\u062c']), ('\ufd38', &['\u0634', '\u062d']), ('\ufd39',
+ &['\u0634', '\u062e']), ('\ufd3a', &['\u0637', '\u0645']), ('\ufd3b', &['\u0638',
+ '\u0645']), ('\ufd3c', &['\u0627', '\u064b']), ('\ufd3d', &['\u0627', '\u064b']), ('\ufd50',
+ &['\u062a', '\u062c', '\u0645']), ('\ufd51', &['\u062a', '\u062d', '\u062c']), ('\ufd52',
+ &['\u062a', '\u062d', '\u062c']), ('\ufd53', &['\u062a', '\u062d', '\u0645']), ('\ufd54',
+ &['\u062a', '\u062e', '\u0645']), ('\ufd55', &['\u062a', '\u0645', '\u062c']), ('\ufd56',
+ &['\u062a', '\u0645', '\u062d']), ('\ufd57', &['\u062a', '\u0645', '\u062e']), ('\ufd58',
+ &['\u062c', '\u0645', '\u062d']), ('\ufd59', &['\u062c', '\u0645', '\u062d']), ('\ufd5a',
+ &['\u062d', '\u0645', '\u064a']), ('\ufd5b', &['\u062d', '\u0645', '\u0649']), ('\ufd5c',
+ &['\u0633', '\u062d', '\u062c']), ('\ufd5d', &['\u0633', '\u062c', '\u062d']), ('\ufd5e',
+ &['\u0633', '\u062c', '\u0649']), ('\ufd5f', &['\u0633', '\u0645', '\u062d']), ('\ufd60',
+ &['\u0633', '\u0645', '\u062d']), ('\ufd61', &['\u0633', '\u0645', '\u062c']), ('\ufd62',
+ &['\u0633', '\u0645', '\u0645']), ('\ufd63', &['\u0633', '\u0645', '\u0645']), ('\ufd64',
+ &['\u0635', '\u062d', '\u062d']), ('\ufd65', &['\u0635', '\u062d', '\u062d']), ('\ufd66',
+ &['\u0635', '\u0645', '\u0645']), ('\ufd67', &['\u0634', '\u062d', '\u0645']), ('\ufd68',
+ &['\u0634', '\u062d', '\u0645']), ('\ufd69', &['\u0634', '\u062c', '\u064a']), ('\ufd6a',
+ &['\u0634', '\u0645', '\u062e']), ('\ufd6b', &['\u0634', '\u0645', '\u062e']), ('\ufd6c',
+ &['\u0634', '\u0645', '\u0645']), ('\ufd6d', &['\u0634', '\u0645', '\u0645']), ('\ufd6e',
+ &['\u0636', '\u062d', '\u0649']), ('\ufd6f', &['\u0636', '\u062e', '\u0645']), ('\ufd70',
+ &['\u0636', '\u062e', '\u0645']), ('\ufd71', &['\u0637', '\u0645', '\u062d']), ('\ufd72',
+ &['\u0637', '\u0645', '\u062d']), ('\ufd73', &['\u0637', '\u0645', '\u0645']), ('\ufd74',
+ &['\u0637', '\u0645', '\u064a']), ('\ufd75', &['\u0639', '\u062c', '\u0645']), ('\ufd76',
+ &['\u0639', '\u0645', '\u0645']), ('\ufd77', &['\u0639', '\u0645', '\u0645']), ('\ufd78',
+ &['\u0639', '\u0645', '\u0649']), ('\ufd79', &['\u063a', '\u0645', '\u0645']), ('\ufd7a',
+ &['\u063a', '\u0645', '\u064a']), ('\ufd7b', &['\u063a', '\u0645', '\u0649']), ('\ufd7c',
+ &['\u0641', '\u062e', '\u0645']), ('\ufd7d', &['\u0641', '\u062e', '\u0645']), ('\ufd7e',
+ &['\u0642', '\u0645', '\u062d']), ('\ufd7f', &['\u0642', '\u0645', '\u0645']), ('\ufd80',
+ &['\u0644', '\u062d', '\u0645']), ('\ufd81', &['\u0644', '\u062d', '\u064a']), ('\ufd82',
+ &['\u0644', '\u062d', '\u0649']), ('\ufd83', &['\u0644', '\u062c', '\u062c']), ('\ufd84',
+ &['\u0644', '\u062c', '\u062c']), ('\ufd85', &['\u0644', '\u062e', '\u0645']), ('\ufd86',
+ &['\u0644', '\u062e', '\u0645']), ('\ufd87', &['\u0644', '\u0645', '\u062d']), ('\ufd88',
+ &['\u0644', '\u0645', '\u062d']), ('\ufd89', &['\u0645', '\u062d', '\u062c']), ('\ufd8a',
+ &['\u0645', '\u062d', '\u0645']), ('\ufd8b', &['\u0645', '\u062d', '\u064a']), ('\ufd8c',
+ &['\u0645', '\u062c', '\u062d']), ('\ufd8d', &['\u0645', '\u062c', '\u0645']), ('\ufd8e',
+ &['\u0645', '\u062e', '\u062c']), ('\ufd8f', &['\u0645', '\u062e', '\u0645']), ('\ufd92',
+ &['\u0645', '\u062c', '\u062e']), ('\ufd93', &['\u0647', '\u0645', '\u062c']), ('\ufd94',
+ &['\u0647', '\u0645', '\u0645']), ('\ufd95', &['\u0646', '\u062d', '\u0645']), ('\ufd96',
+ &['\u0646', '\u062d', '\u0649']), ('\ufd97', &['\u0646', '\u062c', '\u0645']), ('\ufd98',
+ &['\u0646', '\u062c', '\u0645']), ('\ufd99', &['\u0646', '\u062c', '\u0649']), ('\ufd9a',
+ &['\u0646', '\u0645', '\u064a']), ('\ufd9b', &['\u0646', '\u0645', '\u0649']), ('\ufd9c',
+ &['\u064a', '\u0645', '\u0645']), ('\ufd9d', &['\u064a', '\u0645', '\u0645']), ('\ufd9e',
+ &['\u0628', '\u062e', '\u064a']), ('\ufd9f', &['\u062a', '\u062c', '\u064a']), ('\ufda0',
+ &['\u062a', '\u062c', '\u0649']), ('\ufda1', &['\u062a', '\u062e', '\u064a']), ('\ufda2',
+ &['\u062a', '\u062e', '\u0649']), ('\ufda3', &['\u062a', '\u0645', '\u064a']), ('\ufda4',
+ &['\u062a', '\u0645', '\u0649']), ('\ufda5', &['\u062c', '\u0645', '\u064a']), ('\ufda6',
+ &['\u062c', '\u062d', '\u0649']), ('\ufda7', &['\u062c', '\u0645', '\u0649']), ('\ufda8',
+ &['\u0633', '\u062e', '\u0649']), ('\ufda9', &['\u0635', '\u062d', '\u064a']), ('\ufdaa',
+ &['\u0634', '\u062d', '\u064a']), ('\ufdab', &['\u0636', '\u062d', '\u064a']), ('\ufdac',
+ &['\u0644', '\u062c', '\u064a']), ('\ufdad', &['\u0644', '\u0645', '\u064a']), ('\ufdae',
+ &['\u064a', '\u062d', '\u064a']), ('\ufdaf', &['\u064a', '\u062c', '\u064a']), ('\ufdb0',
+ &['\u064a', '\u0645', '\u064a']), ('\ufdb1', &['\u0645', '\u0645', '\u064a']), ('\ufdb2',
+ &['\u0642', '\u0645', '\u064a']), ('\ufdb3', &['\u0646', '\u062d', '\u064a']), ('\ufdb4',
+ &['\u0642', '\u0645', '\u062d']), ('\ufdb5', &['\u0644', '\u062d', '\u0645']), ('\ufdb6',
+ &['\u0639', '\u0645', '\u064a']), ('\ufdb7', &['\u0643', '\u0645', '\u064a']), ('\ufdb8',
+ &['\u0646', '\u062c', '\u062d']), ('\ufdb9', &['\u0645', '\u062e', '\u064a']), ('\ufdba',
+ &['\u0644', '\u062c', '\u0645']), ('\ufdbb', &['\u0643', '\u0645', '\u0645']), ('\ufdbc',
+ &['\u0644', '\u062c', '\u0645']), ('\ufdbd', &['\u0646', '\u062c', '\u062d']), ('\ufdbe',
+ &['\u062c', '\u062d', '\u064a']), ('\ufdbf', &['\u062d', '\u062c', '\u064a']), ('\ufdc0',
+ &['\u0645', '\u062c', '\u064a']), ('\ufdc1', &['\u0641', '\u0645', '\u064a']), ('\ufdc2',
+ &['\u0628', '\u062d', '\u064a']), ('\ufdc3', &['\u0643', '\u0645', '\u0645']), ('\ufdc4',
+ &['\u0639', '\u062c', '\u0645']), ('\ufdc5', &['\u0635', '\u0645', '\u0645']), ('\ufdc6',
+ &['\u0633', '\u062e', '\u064a']), ('\ufdc7', &['\u0646', '\u062c', '\u064a']), ('\ufdf0',
+ &['\u0635', '\u0644', '\u06d2']), ('\ufdf1', &['\u0642', '\u0644', '\u06d2']), ('\ufdf2',
+ &['\u0627', '\u0644', '\u0644', '\u0647']), ('\ufdf3', &['\u0627', '\u0643', '\u0628',
+ '\u0631']), ('\ufdf4', &['\u0645', '\u062d', '\u0645', '\u062f']), ('\ufdf5', &['\u0635',
+ '\u0644', '\u0639', '\u0645']), ('\ufdf6', &['\u0631', '\u0633', '\u0648', '\u0644']),
+ ('\ufdf7', &['\u0639', '\u0644', '\u064a', '\u0647']), ('\ufdf8', &['\u0648', '\u0633',
+ '\u0644', '\u0645']), ('\ufdf9', &['\u0635', '\u0644', '\u0649']), ('\ufdfa', &['\u0635',
+ '\u0644', '\u0649', '\x20', '\u0627', '\u0644', '\u0644', '\u0647', '\x20', '\u0639',
+ '\u0644', '\u064a', '\u0647', '\x20', '\u0648', '\u0633', '\u0644', '\u0645']), ('\ufdfb',
+ &['\u062c', '\u0644', '\x20', '\u062c', '\u0644', '\u0627', '\u0644', '\u0647']), ('\ufdfc',
+ &['\u0631', '\u06cc', '\u0627', '\u0644']), ('\ufe10', &['\x2c']), ('\ufe11', &['\u3001']),
+ ('\ufe12', &['\u3002']), ('\ufe13', &['\x3a']), ('\ufe14', &['\x3b']), ('\ufe15',
+ &['\x21']), ('\ufe16', &['\x3f']), ('\ufe17', &['\u3016']), ('\ufe18', &['\u3017']),
+ ('\ufe19', &['\u2026']), ('\ufe30', &['\u2025']), ('\ufe31', &['\u2014']), ('\ufe32',
+ &['\u2013']), ('\ufe33', &['\x5f']), ('\ufe34', &['\x5f']), ('\ufe35', &['\x28']),
+ ('\ufe36', &['\x29']), ('\ufe37', &['\x7b']), ('\ufe38', &['\x7d']), ('\ufe39',
+ &['\u3014']), ('\ufe3a', &['\u3015']), ('\ufe3b', &['\u3010']), ('\ufe3c', &['\u3011']),
+ ('\ufe3d', &['\u300a']), ('\ufe3e', &['\u300b']), ('\ufe3f', &['\u3008']), ('\ufe40',
+ &['\u3009']), ('\ufe41', &['\u300c']), ('\ufe42', &['\u300d']), ('\ufe43', &['\u300e']),
+ ('\ufe44', &['\u300f']), ('\ufe47', &['\x5b']), ('\ufe48', &['\x5d']), ('\ufe49',
+ &['\u203e']), ('\ufe4a', &['\u203e']), ('\ufe4b', &['\u203e']), ('\ufe4c', &['\u203e']),
+ ('\ufe4d', &['\x5f']), ('\ufe4e', &['\x5f']), ('\ufe4f', &['\x5f']), ('\ufe50', &['\x2c']),
+ ('\ufe51', &['\u3001']), ('\ufe52', &['\x2e']), ('\ufe54', &['\x3b']), ('\ufe55',
+ &['\x3a']), ('\ufe56', &['\x3f']), ('\ufe57', &['\x21']), ('\ufe58', &['\u2014']),
+ ('\ufe59', &['\x28']), ('\ufe5a', &['\x29']), ('\ufe5b', &['\x7b']), ('\ufe5c', &['\x7d']),
+ ('\ufe5d', &['\u3014']), ('\ufe5e', &['\u3015']), ('\ufe5f', &['\x23']), ('\ufe60',
+ &['\x26']), ('\ufe61', &['\x2a']), ('\ufe62', &['\x2b']), ('\ufe63', &['\x2d']), ('\ufe64',
+ &['\x3c']), ('\ufe65', &['\x3e']), ('\ufe66', &['\x3d']), ('\ufe68', &['\x5c']), ('\ufe69',
+ &['\x24']), ('\ufe6a', &['\x25']), ('\ufe6b', &['\x40']), ('\ufe70', &['\x20', '\u064b']),
+ ('\ufe71', &['\u0640', '\u064b']), ('\ufe72', &['\x20', '\u064c']), ('\ufe74', &['\x20',
+ '\u064d']), ('\ufe76', &['\x20', '\u064e']), ('\ufe77', &['\u0640', '\u064e']), ('\ufe78',
+ &['\x20', '\u064f']), ('\ufe79', &['\u0640', '\u064f']), ('\ufe7a', &['\x20', '\u0650']),
+ ('\ufe7b', &['\u0640', '\u0650']), ('\ufe7c', &['\x20', '\u0651']), ('\ufe7d', &['\u0640',
+ '\u0651']), ('\ufe7e', &['\x20', '\u0652']), ('\ufe7f', &['\u0640', '\u0652']), ('\ufe80',
+ &['\u0621']), ('\ufe81', &['\u0622']), ('\ufe82', &['\u0622']), ('\ufe83', &['\u0623']),
+ ('\ufe84', &['\u0623']), ('\ufe85', &['\u0624']), ('\ufe86', &['\u0624']), ('\ufe87',
+ &['\u0625']), ('\ufe88', &['\u0625']), ('\ufe89', &['\u0626']), ('\ufe8a', &['\u0626']),
+ ('\ufe8b', &['\u0626']), ('\ufe8c', &['\u0626']), ('\ufe8d', &['\u0627']), ('\ufe8e',
+ &['\u0627']), ('\ufe8f', &['\u0628']), ('\ufe90', &['\u0628']), ('\ufe91', &['\u0628']),
+ ('\ufe92', &['\u0628']), ('\ufe93', &['\u0629']), ('\ufe94', &['\u0629']), ('\ufe95',
+ &['\u062a']), ('\ufe96', &['\u062a']), ('\ufe97', &['\u062a']), ('\ufe98', &['\u062a']),
+ ('\ufe99', &['\u062b']), ('\ufe9a', &['\u062b']), ('\ufe9b', &['\u062b']), ('\ufe9c',
+ &['\u062b']), ('\ufe9d', &['\u062c']), ('\ufe9e', &['\u062c']), ('\ufe9f', &['\u062c']),
+ ('\ufea0', &['\u062c']), ('\ufea1', &['\u062d']), ('\ufea2', &['\u062d']), ('\ufea3',
+ &['\u062d']), ('\ufea4', &['\u062d']), ('\ufea5', &['\u062e']), ('\ufea6', &['\u062e']),
+ ('\ufea7', &['\u062e']), ('\ufea8', &['\u062e']), ('\ufea9', &['\u062f']), ('\ufeaa',
+ &['\u062f']), ('\ufeab', &['\u0630']), ('\ufeac', &['\u0630']), ('\ufead', &['\u0631']),
+ ('\ufeae', &['\u0631']), ('\ufeaf', &['\u0632']), ('\ufeb0', &['\u0632']), ('\ufeb1',
+ &['\u0633']), ('\ufeb2', &['\u0633']), ('\ufeb3', &['\u0633']), ('\ufeb4', &['\u0633']),
+ ('\ufeb5', &['\u0634']), ('\ufeb6', &['\u0634']), ('\ufeb7', &['\u0634']), ('\ufeb8',
+ &['\u0634']), ('\ufeb9', &['\u0635']), ('\ufeba', &['\u0635']), ('\ufebb', &['\u0635']),
+ ('\ufebc', &['\u0635']), ('\ufebd', &['\u0636']), ('\ufebe', &['\u0636']), ('\ufebf',
+ &['\u0636']), ('\ufec0', &['\u0636']), ('\ufec1', &['\u0637']), ('\ufec2', &['\u0637']),
+ ('\ufec3', &['\u0637']), ('\ufec4', &['\u0637']), ('\ufec5', &['\u0638']), ('\ufec6',
+ &['\u0638']), ('\ufec7', &['\u0638']), ('\ufec8', &['\u0638']), ('\ufec9', &['\u0639']),
+ ('\ufeca', &['\u0639']), ('\ufecb', &['\u0639']), ('\ufecc', &['\u0639']), ('\ufecd',
+ &['\u063a']), ('\ufece', &['\u063a']), ('\ufecf', &['\u063a']), ('\ufed0', &['\u063a']),
+ ('\ufed1', &['\u0641']), ('\ufed2', &['\u0641']), ('\ufed3', &['\u0641']), ('\ufed4',
+ &['\u0641']), ('\ufed5', &['\u0642']), ('\ufed6', &['\u0642']), ('\ufed7', &['\u0642']),
+ ('\ufed8', &['\u0642']), ('\ufed9', &['\u0643']), ('\ufeda', &['\u0643']), ('\ufedb',
+ &['\u0643']), ('\ufedc', &['\u0643']), ('\ufedd', &['\u0644']), ('\ufede', &['\u0644']),
+ ('\ufedf', &['\u0644']), ('\ufee0', &['\u0644']), ('\ufee1', &['\u0645']), ('\ufee2',
+ &['\u0645']), ('\ufee3', &['\u0645']), ('\ufee4', &['\u0645']), ('\ufee5', &['\u0646']),
+ ('\ufee6', &['\u0646']), ('\ufee7', &['\u0646']), ('\ufee8', &['\u0646']), ('\ufee9',
+ &['\u0647']), ('\ufeea', &['\u0647']), ('\ufeeb', &['\u0647']), ('\ufeec', &['\u0647']),
+ ('\ufeed', &['\u0648']), ('\ufeee', &['\u0648']), ('\ufeef', &['\u0649']), ('\ufef0',
+ &['\u0649']), ('\ufef1', &['\u064a']), ('\ufef2', &['\u064a']), ('\ufef3', &['\u064a']),
+ ('\ufef4', &['\u064a']), ('\ufef5', &['\u0644', '\u0622']), ('\ufef6', &['\u0644',
+ '\u0622']), ('\ufef7', &['\u0644', '\u0623']), ('\ufef8', &['\u0644', '\u0623']), ('\ufef9',
+ &['\u0644', '\u0625']), ('\ufefa', &['\u0644', '\u0625']), ('\ufefb', &['\u0644',
+ '\u0627']), ('\ufefc', &['\u0644', '\u0627']), ('\uff01', &['\x21']), ('\uff02', &['\x22']),
+ ('\uff03', &['\x23']), ('\uff04', &['\x24']), ('\uff05', &['\x25']), ('\uff06', &['\x26']),
+ ('\uff07', &['\x27']), ('\uff08', &['\x28']), ('\uff09', &['\x29']), ('\uff0a', &['\x2a']),
+ ('\uff0b', &['\x2b']), ('\uff0c', &['\x2c']), ('\uff0d', &['\x2d']), ('\uff0e', &['\x2e']),
+ ('\uff0f', &['\x2f']), ('\uff10', &['\x30']), ('\uff11', &['\x31']), ('\uff12', &['\x32']),
+ ('\uff13', &['\x33']), ('\uff14', &['\x34']), ('\uff15', &['\x35']), ('\uff16', &['\x36']),
+ ('\uff17', &['\x37']), ('\uff18', &['\x38']), ('\uff19', &['\x39']), ('\uff1a', &['\x3a']),
+ ('\uff1b', &['\x3b']), ('\uff1c', &['\x3c']), ('\uff1d', &['\x3d']), ('\uff1e', &['\x3e']),
+ ('\uff1f', &['\x3f']), ('\uff20', &['\x40']), ('\uff21', &['\x41']), ('\uff22', &['\x42']),
+ ('\uff23', &['\x43']), ('\uff24', &['\x44']), ('\uff25', &['\x45']), ('\uff26', &['\x46']),
+ ('\uff27', &['\x47']), ('\uff28', &['\x48']), ('\uff29', &['\x49']), ('\uff2a', &['\x4a']),
+ ('\uff2b', &['\x4b']), ('\uff2c', &['\x4c']), ('\uff2d', &['\x4d']), ('\uff2e', &['\x4e']),
+ ('\uff2f', &['\x4f']), ('\uff30', &['\x50']), ('\uff31', &['\x51']), ('\uff32', &['\x52']),
+ ('\uff33', &['\x53']), ('\uff34', &['\x54']), ('\uff35', &['\x55']), ('\uff36', &['\x56']),
+ ('\uff37', &['\x57']), ('\uff38', &['\x58']), ('\uff39', &['\x59']), ('\uff3a', &['\x5a']),
+ ('\uff3b', &['\x5b']), ('\uff3c', &['\x5c']), ('\uff3d', &['\x5d']), ('\uff3e', &['\x5e']),
+ ('\uff3f', &['\x5f']), ('\uff40', &['\x60']), ('\uff41', &['\x61']), ('\uff42', &['\x62']),
+ ('\uff43', &['\x63']), ('\uff44', &['\x64']), ('\uff45', &['\x65']), ('\uff46', &['\x66']),
+ ('\uff47', &['\x67']), ('\uff48', &['\x68']), ('\uff49', &['\x69']), ('\uff4a', &['\x6a']),
+ ('\uff4b', &['\x6b']), ('\uff4c', &['\x6c']), ('\uff4d', &['\x6d']), ('\uff4e', &['\x6e']),
+ ('\uff4f', &['\x6f']), ('\uff50', &['\x70']), ('\uff51', &['\x71']), ('\uff52', &['\x72']),
+ ('\uff53', &['\x73']), ('\uff54', &['\x74']), ('\uff55', &['\x75']), ('\uff56', &['\x76']),
+ ('\uff57', &['\x77']), ('\uff58', &['\x78']), ('\uff59', &['\x79']), ('\uff5a', &['\x7a']),
+ ('\uff5b', &['\x7b']), ('\uff5c', &['\x7c']), ('\uff5d', &['\x7d']), ('\uff5e', &['\x7e']),
+ ('\uff5f', &['\u2985']), ('\uff60', &['\u2986']), ('\uff61', &['\u3002']), ('\uff62',
+ &['\u300c']), ('\uff63', &['\u300d']), ('\uff64', &['\u3001']), ('\uff65', &['\u30fb']),
+ ('\uff66', &['\u30f2']), ('\uff67', &['\u30a1']), ('\uff68', &['\u30a3']), ('\uff69',
+ &['\u30a5']), ('\uff6a', &['\u30a7']), ('\uff6b', &['\u30a9']), ('\uff6c', &['\u30e3']),
+ ('\uff6d', &['\u30e5']), ('\uff6e', &['\u30e7']), ('\uff6f', &['\u30c3']), ('\uff70',
+ &['\u30fc']), ('\uff71', &['\u30a2']), ('\uff72', &['\u30a4']), ('\uff73', &['\u30a6']),
+ ('\uff74', &['\u30a8']), ('\uff75', &['\u30aa']), ('\uff76', &['\u30ab']), ('\uff77',
+ &['\u30ad']), ('\uff78', &['\u30af']), ('\uff79', &['\u30b1']), ('\uff7a', &['\u30b3']),
+ ('\uff7b', &['\u30b5']), ('\uff7c', &['\u30b7']), ('\uff7d', &['\u30b9']), ('\uff7e',
+ &['\u30bb']), ('\uff7f', &['\u30bd']), ('\uff80', &['\u30bf']), ('\uff81', &['\u30c1']),
+ ('\uff82', &['\u30c4']), ('\uff83', &['\u30c6']), ('\uff84', &['\u30c8']), ('\uff85',
+ &['\u30ca']), ('\uff86', &['\u30cb']), ('\uff87', &['\u30cc']), ('\uff88', &['\u30cd']),
+ ('\uff89', &['\u30ce']), ('\uff8a', &['\u30cf']), ('\uff8b', &['\u30d2']), ('\uff8c',
+ &['\u30d5']), ('\uff8d', &['\u30d8']), ('\uff8e', &['\u30db']), ('\uff8f', &['\u30de']),
+ ('\uff90', &['\u30df']), ('\uff91', &['\u30e0']), ('\uff92', &['\u30e1']), ('\uff93',
+ &['\u30e2']), ('\uff94', &['\u30e4']), ('\uff95', &['\u30e6']), ('\uff96', &['\u30e8']),
+ ('\uff97', &['\u30e9']), ('\uff98', &['\u30ea']), ('\uff99', &['\u30eb']), ('\uff9a',
+ &['\u30ec']), ('\uff9b', &['\u30ed']), ('\uff9c', &['\u30ef']), ('\uff9d', &['\u30f3']),
+ ('\uff9e', &['\u3099']), ('\uff9f', &['\u309a']), ('\uffa0', &['\u3164']), ('\uffa1',
+ &['\u3131']), ('\uffa2', &['\u3132']), ('\uffa3', &['\u3133']), ('\uffa4', &['\u3134']),
+ ('\uffa5', &['\u3135']), ('\uffa6', &['\u3136']), ('\uffa7', &['\u3137']), ('\uffa8',
+ &['\u3138']), ('\uffa9', &['\u3139']), ('\uffaa', &['\u313a']), ('\uffab', &['\u313b']),
+ ('\uffac', &['\u313c']), ('\uffad', &['\u313d']), ('\uffae', &['\u313e']), ('\uffaf',
+ &['\u313f']), ('\uffb0', &['\u3140']), ('\uffb1', &['\u3141']), ('\uffb2', &['\u3142']),
+ ('\uffb3', &['\u3143']), ('\uffb4', &['\u3144']), ('\uffb5', &['\u3145']), ('\uffb6',
+ &['\u3146']), ('\uffb7', &['\u3147']), ('\uffb8', &['\u3148']), ('\uffb9', &['\u3149']),
+ ('\uffba', &['\u314a']), ('\uffbb', &['\u314b']), ('\uffbc', &['\u314c']), ('\uffbd',
+ &['\u314d']), ('\uffbe', &['\u314e']), ('\uffc2', &['\u314f']), ('\uffc3', &['\u3150']),
+ ('\uffc4', &['\u3151']), ('\uffc5', &['\u3152']), ('\uffc6', &['\u3153']), ('\uffc7',
+ &['\u3154']), ('\uffca', &['\u3155']), ('\uffcb', &['\u3156']), ('\uffcc', &['\u3157']),
+ ('\uffcd', &['\u3158']), ('\uffce', &['\u3159']), ('\uffcf', &['\u315a']), ('\uffd2',
+ &['\u315b']), ('\uffd3', &['\u315c']), ('\uffd4', &['\u315d']), ('\uffd5', &['\u315e']),
+ ('\uffd6', &['\u315f']), ('\uffd7', &['\u3160']), ('\uffda', &['\u3161']), ('\uffdb',
+ &['\u3162']), ('\uffdc', &['\u3163']), ('\uffe0', &['\xa2']), ('\uffe1', &['\xa3']),
+ ('\uffe2', &['\xac']), ('\uffe3', &['\xaf']), ('\uffe4', &['\xa6']), ('\uffe5', &['\xa5']),
+ ('\uffe6', &['\u20a9']), ('\uffe8', &['\u2502']), ('\uffe9', &['\u2190']), ('\uffea',
+ &['\u2191']), ('\uffeb', &['\u2192']), ('\uffec', &['\u2193']), ('\uffed', &['\u25a0']),
+ ('\uffee', &['\u25cb']), ('\U0001d400', &['\x41']), ('\U0001d401', &['\x42']),
+ ('\U0001d402', &['\x43']), ('\U0001d403', &['\x44']), ('\U0001d404', &['\x45']),
+ ('\U0001d405', &['\x46']), ('\U0001d406', &['\x47']), ('\U0001d407', &['\x48']),
+ ('\U0001d408', &['\x49']), ('\U0001d409', &['\x4a']), ('\U0001d40a', &['\x4b']),
+ ('\U0001d40b', &['\x4c']), ('\U0001d40c', &['\x4d']), ('\U0001d40d', &['\x4e']),
+ ('\U0001d40e', &['\x4f']), ('\U0001d40f', &['\x50']), ('\U0001d410', &['\x51']),
+ ('\U0001d411', &['\x52']), ('\U0001d412', &['\x53']), ('\U0001d413', &['\x54']),
+ ('\U0001d414', &['\x55']), ('\U0001d415', &['\x56']), ('\U0001d416', &['\x57']),
+ ('\U0001d417', &['\x58']), ('\U0001d418', &['\x59']), ('\U0001d419', &['\x5a']),
+ ('\U0001d41a', &['\x61']), ('\U0001d41b', &['\x62']), ('\U0001d41c', &['\x63']),
+ ('\U0001d41d', &['\x64']), ('\U0001d41e', &['\x65']), ('\U0001d41f', &['\x66']),
+ ('\U0001d420', &['\x67']), ('\U0001d421', &['\x68']), ('\U0001d422', &['\x69']),
+ ('\U0001d423', &['\x6a']), ('\U0001d424', &['\x6b']), ('\U0001d425', &['\x6c']),
+ ('\U0001d426', &['\x6d']), ('\U0001d427', &['\x6e']), ('\U0001d428', &['\x6f']),
+ ('\U0001d429', &['\x70']), ('\U0001d42a', &['\x71']), ('\U0001d42b', &['\x72']),
+ ('\U0001d42c', &['\x73']), ('\U0001d42d', &['\x74']), ('\U0001d42e', &['\x75']),
+ ('\U0001d42f', &['\x76']), ('\U0001d430', &['\x77']), ('\U0001d431', &['\x78']),
+ ('\U0001d432', &['\x79']), ('\U0001d433', &['\x7a']), ('\U0001d434', &['\x41']),
+ ('\U0001d435', &['\x42']), ('\U0001d436', &['\x43']), ('\U0001d437', &['\x44']),
+ ('\U0001d438', &['\x45']), ('\U0001d439', &['\x46']), ('\U0001d43a', &['\x47']),
+ ('\U0001d43b', &['\x48']), ('\U0001d43c', &['\x49']), ('\U0001d43d', &['\x4a']),
+ ('\U0001d43e', &['\x4b']), ('\U0001d43f', &['\x4c']), ('\U0001d440', &['\x4d']),
+ ('\U0001d441', &['\x4e']), ('\U0001d442', &['\x4f']), ('\U0001d443', &['\x50']),
+ ('\U0001d444', &['\x51']), ('\U0001d445', &['\x52']), ('\U0001d446', &['\x53']),
+ ('\U0001d447', &['\x54']), ('\U0001d448', &['\x55']), ('\U0001d449', &['\x56']),
+ ('\U0001d44a', &['\x57']), ('\U0001d44b', &['\x58']), ('\U0001d44c', &['\x59']),
+ ('\U0001d44d', &['\x5a']), ('\U0001d44e', &['\x61']), ('\U0001d44f', &['\x62']),
+ ('\U0001d450', &['\x63']), ('\U0001d451', &['\x64']), ('\U0001d452', &['\x65']),
+ ('\U0001d453', &['\x66']), ('\U0001d454', &['\x67']), ('\U0001d456', &['\x69']),
+ ('\U0001d457', &['\x6a']), ('\U0001d458', &['\x6b']), ('\U0001d459', &['\x6c']),
+ ('\U0001d45a', &['\x6d']), ('\U0001d45b', &['\x6e']), ('\U0001d45c', &['\x6f']),
+ ('\U0001d45d', &['\x70']), ('\U0001d45e', &['\x71']), ('\U0001d45f', &['\x72']),
+ ('\U0001d460', &['\x73']), ('\U0001d461', &['\x74']), ('\U0001d462', &['\x75']),
+ ('\U0001d463', &['\x76']), ('\U0001d464', &['\x77']), ('\U0001d465', &['\x78']),
+ ('\U0001d466', &['\x79']), ('\U0001d467', &['\x7a']), ('\U0001d468', &['\x41']),
+ ('\U0001d469', &['\x42']), ('\U0001d46a', &['\x43']), ('\U0001d46b', &['\x44']),
+ ('\U0001d46c', &['\x45']), ('\U0001d46d', &['\x46']), ('\U0001d46e', &['\x47']),
+ ('\U0001d46f', &['\x48']), ('\U0001d470', &['\x49']), ('\U0001d471', &['\x4a']),
+ ('\U0001d472', &['\x4b']), ('\U0001d473', &['\x4c']), ('\U0001d474', &['\x4d']),
+ ('\U0001d475', &['\x4e']), ('\U0001d476', &['\x4f']), ('\U0001d477', &['\x50']),
+ ('\U0001d478', &['\x51']), ('\U0001d479', &['\x52']), ('\U0001d47a', &['\x53']),
+ ('\U0001d47b', &['\x54']), ('\U0001d47c', &['\x55']), ('\U0001d47d', &['\x56']),
+ ('\U0001d47e', &['\x57']), ('\U0001d47f', &['\x58']), ('\U0001d480', &['\x59']),
+ ('\U0001d481', &['\x5a']), ('\U0001d482', &['\x61']), ('\U0001d483', &['\x62']),
+ ('\U0001d484', &['\x63']), ('\U0001d485', &['\x64']), ('\U0001d486', &['\x65']),
+ ('\U0001d487', &['\x66']), ('\U0001d488', &['\x67']), ('\U0001d489', &['\x68']),
+ ('\U0001d48a', &['\x69']), ('\U0001d48b', &['\x6a']), ('\U0001d48c', &['\x6b']),
+ ('\U0001d48d', &['\x6c']), ('\U0001d48e', &['\x6d']), ('\U0001d48f', &['\x6e']),
+ ('\U0001d490', &['\x6f']), ('\U0001d491', &['\x70']), ('\U0001d492', &['\x71']),
+ ('\U0001d493', &['\x72']), ('\U0001d494', &['\x73']), ('\U0001d495', &['\x74']),
+ ('\U0001d496', &['\x75']), ('\U0001d497', &['\x76']), ('\U0001d498', &['\x77']),
+ ('\U0001d499', &['\x78']), ('\U0001d49a', &['\x79']), ('\U0001d49b', &['\x7a']),
+ ('\U0001d49c', &['\x41']), ('\U0001d49e', &['\x43']), ('\U0001d49f', &['\x44']),
+ ('\U0001d4a2', &['\x47']), ('\U0001d4a5', &['\x4a']), ('\U0001d4a6', &['\x4b']),
+ ('\U0001d4a9', &['\x4e']), ('\U0001d4aa', &['\x4f']), ('\U0001d4ab', &['\x50']),
+ ('\U0001d4ac', &['\x51']), ('\U0001d4ae', &['\x53']), ('\U0001d4af', &['\x54']),
+ ('\U0001d4b0', &['\x55']), ('\U0001d4b1', &['\x56']), ('\U0001d4b2', &['\x57']),
+ ('\U0001d4b3', &['\x58']), ('\U0001d4b4', &['\x59']), ('\U0001d4b5', &['\x5a']),
+ ('\U0001d4b6', &['\x61']), ('\U0001d4b7', &['\x62']), ('\U0001d4b8', &['\x63']),
+ ('\U0001d4b9', &['\x64']), ('\U0001d4bb', &['\x66']), ('\U0001d4bd', &['\x68']),
+ ('\U0001d4be', &['\x69']), ('\U0001d4bf', &['\x6a']), ('\U0001d4c0', &['\x6b']),
+ ('\U0001d4c1', &['\x6c']), ('\U0001d4c2', &['\x6d']), ('\U0001d4c3', &['\x6e']),
+ ('\U0001d4c5', &['\x70']), ('\U0001d4c6', &['\x71']), ('\U0001d4c7', &['\x72']),
+ ('\U0001d4c8', &['\x73']), ('\U0001d4c9', &['\x74']), ('\U0001d4ca', &['\x75']),
+ ('\U0001d4cb', &['\x76']), ('\U0001d4cc', &['\x77']), ('\U0001d4cd', &['\x78']),
+ ('\U0001d4ce', &['\x79']), ('\U0001d4cf', &['\x7a']), ('\U0001d4d0', &['\x41']),
+ ('\U0001d4d1', &['\x42']), ('\U0001d4d2', &['\x43']), ('\U0001d4d3', &['\x44']),
+ ('\U0001d4d4', &['\x45']), ('\U0001d4d5', &['\x46']), ('\U0001d4d6', &['\x47']),
+ ('\U0001d4d7', &['\x48']), ('\U0001d4d8', &['\x49']), ('\U0001d4d9', &['\x4a']),
+ ('\U0001d4da', &['\x4b']), ('\U0001d4db', &['\x4c']), ('\U0001d4dc', &['\x4d']),
+ ('\U0001d4dd', &['\x4e']), ('\U0001d4de', &['\x4f']), ('\U0001d4df', &['\x50']),
+ ('\U0001d4e0', &['\x51']), ('\U0001d4e1', &['\x52']), ('\U0001d4e2', &['\x53']),
+ ('\U0001d4e3', &['\x54']), ('\U0001d4e4', &['\x55']), ('\U0001d4e5', &['\x56']),
+ ('\U0001d4e6', &['\x57']), ('\U0001d4e7', &['\x58']), ('\U0001d4e8', &['\x59']),
+ ('\U0001d4e9', &['\x5a']), ('\U0001d4ea', &['\x61']), ('\U0001d4eb', &['\x62']),
+ ('\U0001d4ec', &['\x63']), ('\U0001d4ed', &['\x64']), ('\U0001d4ee', &['\x65']),
+ ('\U0001d4ef', &['\x66']), ('\U0001d4f0', &['\x67']), ('\U0001d4f1', &['\x68']),
+ ('\U0001d4f2', &['\x69']), ('\U0001d4f3', &['\x6a']), ('\U0001d4f4', &['\x6b']),
+ ('\U0001d4f5', &['\x6c']), ('\U0001d4f6', &['\x6d']), ('\U0001d4f7', &['\x6e']),
+ ('\U0001d4f8', &['\x6f']), ('\U0001d4f9', &['\x70']), ('\U0001d4fa', &['\x71']),
+ ('\U0001d4fb', &['\x72']), ('\U0001d4fc', &['\x73']), ('\U0001d4fd', &['\x74']),
+ ('\U0001d4fe', &['\x75']), ('\U0001d4ff', &['\x76']), ('\U0001d500', &['\x77']),
+ ('\U0001d501', &['\x78']), ('\U0001d502', &['\x79']), ('\U0001d503', &['\x7a']),
+ ('\U0001d504', &['\x41']), ('\U0001d505', &['\x42']), ('\U0001d507', &['\x44']),
+ ('\U0001d508', &['\x45']), ('\U0001d509', &['\x46']), ('\U0001d50a', &['\x47']),
+ ('\U0001d50d', &['\x4a']), ('\U0001d50e', &['\x4b']), ('\U0001d50f', &['\x4c']),
+ ('\U0001d510', &['\x4d']), ('\U0001d511', &['\x4e']), ('\U0001d512', &['\x4f']),
+ ('\U0001d513', &['\x50']), ('\U0001d514', &['\x51']), ('\U0001d516', &['\x53']),
+ ('\U0001d517', &['\x54']), ('\U0001d518', &['\x55']), ('\U0001d519', &['\x56']),
+ ('\U0001d51a', &['\x57']), ('\U0001d51b', &['\x58']), ('\U0001d51c', &['\x59']),
+ ('\U0001d51e', &['\x61']), ('\U0001d51f', &['\x62']), ('\U0001d520', &['\x63']),
+ ('\U0001d521', &['\x64']), ('\U0001d522', &['\x65']), ('\U0001d523', &['\x66']),
+ ('\U0001d524', &['\x67']), ('\U0001d525', &['\x68']), ('\U0001d526', &['\x69']),
+ ('\U0001d527', &['\x6a']), ('\U0001d528', &['\x6b']), ('\U0001d529', &['\x6c']),
+ ('\U0001d52a', &['\x6d']), ('\U0001d52b', &['\x6e']), ('\U0001d52c', &['\x6f']),
+ ('\U0001d52d', &['\x70']), ('\U0001d52e', &['\x71']), ('\U0001d52f', &['\x72']),
+ ('\U0001d530', &['\x73']), ('\U0001d531', &['\x74']), ('\U0001d532', &['\x75']),
+ ('\U0001d533', &['\x76']), ('\U0001d534', &['\x77']), ('\U0001d535', &['\x78']),
+ ('\U0001d536', &['\x79']), ('\U0001d537', &['\x7a']), ('\U0001d538', &['\x41']),
+ ('\U0001d539', &['\x42']), ('\U0001d53b', &['\x44']), ('\U0001d53c', &['\x45']),
+ ('\U0001d53d', &['\x46']), ('\U0001d53e', &['\x47']), ('\U0001d540', &['\x49']),
+ ('\U0001d541', &['\x4a']), ('\U0001d542', &['\x4b']), ('\U0001d543', &['\x4c']),
+ ('\U0001d544', &['\x4d']), ('\U0001d546', &['\x4f']), ('\U0001d54a', &['\x53']),
+ ('\U0001d54b', &['\x54']), ('\U0001d54c', &['\x55']), ('\U0001d54d', &['\x56']),
+ ('\U0001d54e', &['\x57']), ('\U0001d54f', &['\x58']), ('\U0001d550', &['\x59']),
+ ('\U0001d552', &['\x61']), ('\U0001d553', &['\x62']), ('\U0001d554', &['\x63']),
+ ('\U0001d555', &['\x64']), ('\U0001d556', &['\x65']), ('\U0001d557', &['\x66']),
+ ('\U0001d558', &['\x67']), ('\U0001d559', &['\x68']), ('\U0001d55a', &['\x69']),
+ ('\U0001d55b', &['\x6a']), ('\U0001d55c', &['\x6b']), ('\U0001d55d', &['\x6c']),
+ ('\U0001d55e', &['\x6d']), ('\U0001d55f', &['\x6e']), ('\U0001d560', &['\x6f']),
+ ('\U0001d561', &['\x70']), ('\U0001d562', &['\x71']), ('\U0001d563', &['\x72']),
+ ('\U0001d564', &['\x73']), ('\U0001d565', &['\x74']), ('\U0001d566', &['\x75']),
+ ('\U0001d567', &['\x76']), ('\U0001d568', &['\x77']), ('\U0001d569', &['\x78']),
+ ('\U0001d56a', &['\x79']), ('\U0001d56b', &['\x7a']), ('\U0001d56c', &['\x41']),
+ ('\U0001d56d', &['\x42']), ('\U0001d56e', &['\x43']), ('\U0001d56f', &['\x44']),
+ ('\U0001d570', &['\x45']), ('\U0001d571', &['\x46']), ('\U0001d572', &['\x47']),
+ ('\U0001d573', &['\x48']), ('\U0001d574', &['\x49']), ('\U0001d575', &['\x4a']),
+ ('\U0001d576', &['\x4b']), ('\U0001d577', &['\x4c']), ('\U0001d578', &['\x4d']),
+ ('\U0001d579', &['\x4e']), ('\U0001d57a', &['\x4f']), ('\U0001d57b', &['\x50']),
+ ('\U0001d57c', &['\x51']), ('\U0001d57d', &['\x52']), ('\U0001d57e', &['\x53']),
+ ('\U0001d57f', &['\x54']), ('\U0001d580', &['\x55']), ('\U0001d581', &['\x56']),
+ ('\U0001d582', &['\x57']), ('\U0001d583', &['\x58']), ('\U0001d584', &['\x59']),
+ ('\U0001d585', &['\x5a']), ('\U0001d586', &['\x61']), ('\U0001d587', &['\x62']),
+ ('\U0001d588', &['\x63']), ('\U0001d589', &['\x64']), ('\U0001d58a', &['\x65']),
+ ('\U0001d58b', &['\x66']), ('\U0001d58c', &['\x67']), ('\U0001d58d', &['\x68']),
+ ('\U0001d58e', &['\x69']), ('\U0001d58f', &['\x6a']), ('\U0001d590', &['\x6b']),
+ ('\U0001d591', &['\x6c']), ('\U0001d592', &['\x6d']), ('\U0001d593', &['\x6e']),
+ ('\U0001d594', &['\x6f']), ('\U0001d595', &['\x70']), ('\U0001d596', &['\x71']),
+ ('\U0001d597', &['\x72']), ('\U0001d598', &['\x73']), ('\U0001d599', &['\x74']),
+ ('\U0001d59a', &['\x75']), ('\U0001d59b', &['\x76']), ('\U0001d59c', &['\x77']),
+ ('\U0001d59d', &['\x78']), ('\U0001d59e', &['\x79']), ('\U0001d59f', &['\x7a']),
+ ('\U0001d5a0', &['\x41']), ('\U0001d5a1', &['\x42']), ('\U0001d5a2', &['\x43']),
+ ('\U0001d5a3', &['\x44']), ('\U0001d5a4', &['\x45']), ('\U0001d5a5', &['\x46']),
+ ('\U0001d5a6', &['\x47']), ('\U0001d5a7', &['\x48']), ('\U0001d5a8', &['\x49']),
+ ('\U0001d5a9', &['\x4a']), ('\U0001d5aa', &['\x4b']), ('\U0001d5ab', &['\x4c']),
+ ('\U0001d5ac', &['\x4d']), ('\U0001d5ad', &['\x4e']), ('\U0001d5ae', &['\x4f']),
+ ('\U0001d5af', &['\x50']), ('\U0001d5b0', &['\x51']), ('\U0001d5b1', &['\x52']),
+ ('\U0001d5b2', &['\x53']), ('\U0001d5b3', &['\x54']), ('\U0001d5b4', &['\x55']),
+ ('\U0001d5b5', &['\x56']), ('\U0001d5b6', &['\x57']), ('\U0001d5b7', &['\x58']),
+ ('\U0001d5b8', &['\x59']), ('\U0001d5b9', &['\x5a']), ('\U0001d5ba', &['\x61']),
+ ('\U0001d5bb', &['\x62']), ('\U0001d5bc', &['\x63']), ('\U0001d5bd', &['\x64']),
+ ('\U0001d5be', &['\x65']), ('\U0001d5bf', &['\x66']), ('\U0001d5c0', &['\x67']),
+ ('\U0001d5c1', &['\x68']), ('\U0001d5c2', &['\x69']), ('\U0001d5c3', &['\x6a']),
+ ('\U0001d5c4', &['\x6b']), ('\U0001d5c5', &['\x6c']), ('\U0001d5c6', &['\x6d']),
+ ('\U0001d5c7', &['\x6e']), ('\U0001d5c8', &['\x6f']), ('\U0001d5c9', &['\x70']),
+ ('\U0001d5ca', &['\x71']), ('\U0001d5cb', &['\x72']), ('\U0001d5cc', &['\x73']),
+ ('\U0001d5cd', &['\x74']), ('\U0001d5ce', &['\x75']), ('\U0001d5cf', &['\x76']),
+ ('\U0001d5d0', &['\x77']), ('\U0001d5d1', &['\x78']), ('\U0001d5d2', &['\x79']),
+ ('\U0001d5d3', &['\x7a']), ('\U0001d5d4', &['\x41']), ('\U0001d5d5', &['\x42']),
+ ('\U0001d5d6', &['\x43']), ('\U0001d5d7', &['\x44']), ('\U0001d5d8', &['\x45']),
+ ('\U0001d5d9', &['\x46']), ('\U0001d5da', &['\x47']), ('\U0001d5db', &['\x48']),
+ ('\U0001d5dc', &['\x49']), ('\U0001d5dd', &['\x4a']), ('\U0001d5de', &['\x4b']),
+ ('\U0001d5df', &['\x4c']), ('\U0001d5e0', &['\x4d']), ('\U0001d5e1', &['\x4e']),
+ ('\U0001d5e2', &['\x4f']), ('\U0001d5e3', &['\x50']), ('\U0001d5e4', &['\x51']),
+ ('\U0001d5e5', &['\x52']), ('\U0001d5e6', &['\x53']), ('\U0001d5e7', &['\x54']),
+ ('\U0001d5e8', &['\x55']), ('\U0001d5e9', &['\x56']), ('\U0001d5ea', &['\x57']),
+ ('\U0001d5eb', &['\x58']), ('\U0001d5ec', &['\x59']), ('\U0001d5ed', &['\x5a']),
+ ('\U0001d5ee', &['\x61']), ('\U0001d5ef', &['\x62']), ('\U0001d5f0', &['\x63']),
+ ('\U0001d5f1', &['\x64']), ('\U0001d5f2', &['\x65']), ('\U0001d5f3', &['\x66']),
+ ('\U0001d5f4', &['\x67']), ('\U0001d5f5', &['\x68']), ('\U0001d5f6', &['\x69']),
+ ('\U0001d5f7', &['\x6a']), ('\U0001d5f8', &['\x6b']), ('\U0001d5f9', &['\x6c']),
+ ('\U0001d5fa', &['\x6d']), ('\U0001d5fb', &['\x6e']), ('\U0001d5fc', &['\x6f']),
+ ('\U0001d5fd', &['\x70']), ('\U0001d5fe', &['\x71']), ('\U0001d5ff', &['\x72']),
+ ('\U0001d600', &['\x73']), ('\U0001d601', &['\x74']), ('\U0001d602', &['\x75']),
+ ('\U0001d603', &['\x76']), ('\U0001d604', &['\x77']), ('\U0001d605', &['\x78']),
+ ('\U0001d606', &['\x79']), ('\U0001d607', &['\x7a']), ('\U0001d608', &['\x41']),
+ ('\U0001d609', &['\x42']), ('\U0001d60a', &['\x43']), ('\U0001d60b', &['\x44']),
+ ('\U0001d60c', &['\x45']), ('\U0001d60d', &['\x46']), ('\U0001d60e', &['\x47']),
+ ('\U0001d60f', &['\x48']), ('\U0001d610', &['\x49']), ('\U0001d611', &['\x4a']),
+ ('\U0001d612', &['\x4b']), ('\U0001d613', &['\x4c']), ('\U0001d614', &['\x4d']),
+ ('\U0001d615', &['\x4e']), ('\U0001d616', &['\x4f']), ('\U0001d617', &['\x50']),
+ ('\U0001d618', &['\x51']), ('\U0001d619', &['\x52']), ('\U0001d61a', &['\x53']),
+ ('\U0001d61b', &['\x54']), ('\U0001d61c', &['\x55']), ('\U0001d61d', &['\x56']),
+ ('\U0001d61e', &['\x57']), ('\U0001d61f', &['\x58']), ('\U0001d620', &['\x59']),
+ ('\U0001d621', &['\x5a']), ('\U0001d622', &['\x61']), ('\U0001d623', &['\x62']),
+ ('\U0001d624', &['\x63']), ('\U0001d625', &['\x64']), ('\U0001d626', &['\x65']),
+ ('\U0001d627', &['\x66']), ('\U0001d628', &['\x67']), ('\U0001d629', &['\x68']),
+ ('\U0001d62a', &['\x69']), ('\U0001d62b', &['\x6a']), ('\U0001d62c', &['\x6b']),
+ ('\U0001d62d', &['\x6c']), ('\U0001d62e', &['\x6d']), ('\U0001d62f', &['\x6e']),
+ ('\U0001d630', &['\x6f']), ('\U0001d631', &['\x70']), ('\U0001d632', &['\x71']),
+ ('\U0001d633', &['\x72']), ('\U0001d634', &['\x73']), ('\U0001d635', &['\x74']),
+ ('\U0001d636', &['\x75']), ('\U0001d637', &['\x76']), ('\U0001d638', &['\x77']),
+ ('\U0001d639', &['\x78']), ('\U0001d63a', &['\x79']), ('\U0001d63b', &['\x7a']),
+ ('\U0001d63c', &['\x41']), ('\U0001d63d', &['\x42']), ('\U0001d63e', &['\x43']),
+ ('\U0001d63f', &['\x44']), ('\U0001d640', &['\x45']), ('\U0001d641', &['\x46']),
+ ('\U0001d642', &['\x47']), ('\U0001d643', &['\x48']), ('\U0001d644', &['\x49']),
+ ('\U0001d645', &['\x4a']), ('\U0001d646', &['\x4b']), ('\U0001d647', &['\x4c']),
+ ('\U0001d648', &['\x4d']), ('\U0001d649', &['\x4e']), ('\U0001d64a', &['\x4f']),
+ ('\U0001d64b', &['\x50']), ('\U0001d64c', &['\x51']), ('\U0001d64d', &['\x52']),
+ ('\U0001d64e', &['\x53']), ('\U0001d64f', &['\x54']), ('\U0001d650', &['\x55']),
+ ('\U0001d651', &['\x56']), ('\U0001d652', &['\x57']), ('\U0001d653', &['\x58']),
+ ('\U0001d654', &['\x59']), ('\U0001d655', &['\x5a']), ('\U0001d656', &['\x61']),
+ ('\U0001d657', &['\x62']), ('\U0001d658', &['\x63']), ('\U0001d659', &['\x64']),
+ ('\U0001d65a', &['\x65']), ('\U0001d65b', &['\x66']), ('\U0001d65c', &['\x67']),
+ ('\U0001d65d', &['\x68']), ('\U0001d65e', &['\x69']), ('\U0001d65f', &['\x6a']),
+ ('\U0001d660', &['\x6b']), ('\U0001d661', &['\x6c']), ('\U0001d662', &['\x6d']),
+ ('\U0001d663', &['\x6e']), ('\U0001d664', &['\x6f']), ('\U0001d665', &['\x70']),
+ ('\U0001d666', &['\x71']), ('\U0001d667', &['\x72']), ('\U0001d668', &['\x73']),
+ ('\U0001d669', &['\x74']), ('\U0001d66a', &['\x75']), ('\U0001d66b', &['\x76']),
+ ('\U0001d66c', &['\x77']), ('\U0001d66d', &['\x78']), ('\U0001d66e', &['\x79']),
+ ('\U0001d66f', &['\x7a']), ('\U0001d670', &['\x41']), ('\U0001d671', &['\x42']),
+ ('\U0001d672', &['\x43']), ('\U0001d673', &['\x44']), ('\U0001d674', &['\x45']),
+ ('\U0001d675', &['\x46']), ('\U0001d676', &['\x47']), ('\U0001d677', &['\x48']),
+ ('\U0001d678', &['\x49']), ('\U0001d679', &['\x4a']), ('\U0001d67a', &['\x4b']),
+ ('\U0001d67b', &['\x4c']), ('\U0001d67c', &['\x4d']), ('\U0001d67d', &['\x4e']),
+ ('\U0001d67e', &['\x4f']), ('\U0001d67f', &['\x50']), ('\U0001d680', &['\x51']),
+ ('\U0001d681', &['\x52']), ('\U0001d682', &['\x53']), ('\U0001d683', &['\x54']),
+ ('\U0001d684', &['\x55']), ('\U0001d685', &['\x56']), ('\U0001d686', &['\x57']),
+ ('\U0001d687', &['\x58']), ('\U0001d688', &['\x59']), ('\U0001d689', &['\x5a']),
+ ('\U0001d68a', &['\x61']), ('\U0001d68b', &['\x62']), ('\U0001d68c', &['\x63']),
+ ('\U0001d68d', &['\x64']), ('\U0001d68e', &['\x65']), ('\U0001d68f', &['\x66']),
+ ('\U0001d690', &['\x67']), ('\U0001d691', &['\x68']), ('\U0001d692', &['\x69']),
+ ('\U0001d693', &['\x6a']), ('\U0001d694', &['\x6b']), ('\U0001d695', &['\x6c']),
+ ('\U0001d696', &['\x6d']), ('\U0001d697', &['\x6e']), ('\U0001d698', &['\x6f']),
+ ('\U0001d699', &['\x70']), ('\U0001d69a', &['\x71']), ('\U0001d69b', &['\x72']),
+ ('\U0001d69c', &['\x73']), ('\U0001d69d', &['\x74']), ('\U0001d69e', &['\x75']),
+ ('\U0001d69f', &['\x76']), ('\U0001d6a0', &['\x77']), ('\U0001d6a1', &['\x78']),
+ ('\U0001d6a2', &['\x79']), ('\U0001d6a3', &['\x7a']), ('\U0001d6a4', &['\u0131']),
+ ('\U0001d6a5', &['\u0237']), ('\U0001d6a8', &['\u0391']), ('\U0001d6a9', &['\u0392']),
+ ('\U0001d6aa', &['\u0393']), ('\U0001d6ab', &['\u0394']), ('\U0001d6ac', &['\u0395']),
+ ('\U0001d6ad', &['\u0396']), ('\U0001d6ae', &['\u0397']), ('\U0001d6af', &['\u0398']),
+ ('\U0001d6b0', &['\u0399']), ('\U0001d6b1', &['\u039a']), ('\U0001d6b2', &['\u039b']),
+ ('\U0001d6b3', &['\u039c']), ('\U0001d6b4', &['\u039d']), ('\U0001d6b5', &['\u039e']),
+ ('\U0001d6b6', &['\u039f']), ('\U0001d6b7', &['\u03a0']), ('\U0001d6b8', &['\u03a1']),
+ ('\U0001d6b9', &['\u03f4']), ('\U0001d6ba', &['\u03a3']), ('\U0001d6bb', &['\u03a4']),
+ ('\U0001d6bc', &['\u03a5']), ('\U0001d6bd', &['\u03a6']), ('\U0001d6be', &['\u03a7']),
+ ('\U0001d6bf', &['\u03a8']), ('\U0001d6c0', &['\u03a9']), ('\U0001d6c1', &['\u2207']),
+ ('\U0001d6c2', &['\u03b1']), ('\U0001d6c3', &['\u03b2']), ('\U0001d6c4', &['\u03b3']),
+ ('\U0001d6c5', &['\u03b4']), ('\U0001d6c6', &['\u03b5']), ('\U0001d6c7', &['\u03b6']),
+ ('\U0001d6c8', &['\u03b7']), ('\U0001d6c9', &['\u03b8']), ('\U0001d6ca', &['\u03b9']),
+ ('\U0001d6cb', &['\u03ba']), ('\U0001d6cc', &['\u03bb']), ('\U0001d6cd', &['\u03bc']),
+ ('\U0001d6ce', &['\u03bd']), ('\U0001d6cf', &['\u03be']), ('\U0001d6d0', &['\u03bf']),
+ ('\U0001d6d1', &['\u03c0']), ('\U0001d6d2', &['\u03c1']), ('\U0001d6d3', &['\u03c2']),
+ ('\U0001d6d4', &['\u03c3']), ('\U0001d6d5', &['\u03c4']), ('\U0001d6d6', &['\u03c5']),
+ ('\U0001d6d7', &['\u03c6']), ('\U0001d6d8', &['\u03c7']), ('\U0001d6d9', &['\u03c8']),
+ ('\U0001d6da', &['\u03c9']), ('\U0001d6db', &['\u2202']), ('\U0001d6dc', &['\u03f5']),
+ ('\U0001d6dd', &['\u03d1']), ('\U0001d6de', &['\u03f0']), ('\U0001d6df', &['\u03d5']),
+ ('\U0001d6e0', &['\u03f1']), ('\U0001d6e1', &['\u03d6']), ('\U0001d6e2', &['\u0391']),
+ ('\U0001d6e3', &['\u0392']), ('\U0001d6e4', &['\u0393']), ('\U0001d6e5', &['\u0394']),
+ ('\U0001d6e6', &['\u0395']), ('\U0001d6e7', &['\u0396']), ('\U0001d6e8', &['\u0397']),
+ ('\U0001d6e9', &['\u0398']), ('\U0001d6ea', &['\u0399']), ('\U0001d6eb', &['\u039a']),
+ ('\U0001d6ec', &['\u039b']), ('\U0001d6ed', &['\u039c']), ('\U0001d6ee', &['\u039d']),
+ ('\U0001d6ef', &['\u039e']), ('\U0001d6f0', &['\u039f']), ('\U0001d6f1', &['\u03a0']),
+ ('\U0001d6f2', &['\u03a1']), ('\U0001d6f3', &['\u03f4']), ('\U0001d6f4', &['\u03a3']),
+ ('\U0001d6f5', &['\u03a4']), ('\U0001d6f6', &['\u03a5']), ('\U0001d6f7', &['\u03a6']),
+ ('\U0001d6f8', &['\u03a7']), ('\U0001d6f9', &['\u03a8']), ('\U0001d6fa', &['\u03a9']),
+ ('\U0001d6fb', &['\u2207']), ('\U0001d6fc', &['\u03b1']), ('\U0001d6fd', &['\u03b2']),
+ ('\U0001d6fe', &['\u03b3']), ('\U0001d6ff', &['\u03b4']), ('\U0001d700', &['\u03b5']),
+ ('\U0001d701', &['\u03b6']), ('\U0001d702', &['\u03b7']), ('\U0001d703', &['\u03b8']),
+ ('\U0001d704', &['\u03b9']), ('\U0001d705', &['\u03ba']), ('\U0001d706', &['\u03bb']),
+ ('\U0001d707', &['\u03bc']), ('\U0001d708', &['\u03bd']), ('\U0001d709', &['\u03be']),
+ ('\U0001d70a', &['\u03bf']), ('\U0001d70b', &['\u03c0']), ('\U0001d70c', &['\u03c1']),
+ ('\U0001d70d', &['\u03c2']), ('\U0001d70e', &['\u03c3']), ('\U0001d70f', &['\u03c4']),
+ ('\U0001d710', &['\u03c5']), ('\U0001d711', &['\u03c6']), ('\U0001d712', &['\u03c7']),
+ ('\U0001d713', &['\u03c8']), ('\U0001d714', &['\u03c9']), ('\U0001d715', &['\u2202']),
+ ('\U0001d716', &['\u03f5']), ('\U0001d717', &['\u03d1']), ('\U0001d718', &['\u03f0']),
+ ('\U0001d719', &['\u03d5']), ('\U0001d71a', &['\u03f1']), ('\U0001d71b', &['\u03d6']),
+ ('\U0001d71c', &['\u0391']), ('\U0001d71d', &['\u0392']), ('\U0001d71e', &['\u0393']),
+ ('\U0001d71f', &['\u0394']), ('\U0001d720', &['\u0395']), ('\U0001d721', &['\u0396']),
+ ('\U0001d722', &['\u0397']), ('\U0001d723', &['\u0398']), ('\U0001d724', &['\u0399']),
+ ('\U0001d725', &['\u039a']), ('\U0001d726', &['\u039b']), ('\U0001d727', &['\u039c']),
+ ('\U0001d728', &['\u039d']), ('\U0001d729', &['\u039e']), ('\U0001d72a', &['\u039f']),
+ ('\U0001d72b', &['\u03a0']), ('\U0001d72c', &['\u03a1']), ('\U0001d72d', &['\u03f4']),
+ ('\U0001d72e', &['\u03a3']), ('\U0001d72f', &['\u03a4']), ('\U0001d730', &['\u03a5']),
+ ('\U0001d731', &['\u03a6']), ('\U0001d732', &['\u03a7']), ('\U0001d733', &['\u03a8']),
+ ('\U0001d734', &['\u03a9']), ('\U0001d735', &['\u2207']), ('\U0001d736', &['\u03b1']),
+ ('\U0001d737', &['\u03b2']), ('\U0001d738', &['\u03b3']), ('\U0001d739', &['\u03b4']),
+ ('\U0001d73a', &['\u03b5']), ('\U0001d73b', &['\u03b6']), ('\U0001d73c', &['\u03b7']),
+ ('\U0001d73d', &['\u03b8']), ('\U0001d73e', &['\u03b9']), ('\U0001d73f', &['\u03ba']),
+ ('\U0001d740', &['\u03bb']), ('\U0001d741', &['\u03bc']), ('\U0001d742', &['\u03bd']),
+ ('\U0001d743', &['\u03be']), ('\U0001d744', &['\u03bf']), ('\U0001d745', &['\u03c0']),
+ ('\U0001d746', &['\u03c1']), ('\U0001d747', &['\u03c2']), ('\U0001d748', &['\u03c3']),
+ ('\U0001d749', &['\u03c4']), ('\U0001d74a', &['\u03c5']), ('\U0001d74b', &['\u03c6']),
+ ('\U0001d74c', &['\u03c7']), ('\U0001d74d', &['\u03c8']), ('\U0001d74e', &['\u03c9']),
+ ('\U0001d74f', &['\u2202']), ('\U0001d750', &['\u03f5']), ('\U0001d751', &['\u03d1']),
+ ('\U0001d752', &['\u03f0']), ('\U0001d753', &['\u03d5']), ('\U0001d754', &['\u03f1']),
+ ('\U0001d755', &['\u03d6']), ('\U0001d756', &['\u0391']), ('\U0001d757', &['\u0392']),
+ ('\U0001d758', &['\u0393']), ('\U0001d759', &['\u0394']), ('\U0001d75a', &['\u0395']),
+ ('\U0001d75b', &['\u0396']), ('\U0001d75c', &['\u0397']), ('\U0001d75d', &['\u0398']),
+ ('\U0001d75e', &['\u0399']), ('\U0001d75f', &['\u039a']), ('\U0001d760', &['\u039b']),
+ ('\U0001d761', &['\u039c']), ('\U0001d762', &['\u039d']), ('\U0001d763', &['\u039e']),
+ ('\U0001d764', &['\u039f']), ('\U0001d765', &['\u03a0']), ('\U0001d766', &['\u03a1']),
+ ('\U0001d767', &['\u03f4']), ('\U0001d768', &['\u03a3']), ('\U0001d769', &['\u03a4']),
+ ('\U0001d76a', &['\u03a5']), ('\U0001d76b', &['\u03a6']), ('\U0001d76c', &['\u03a7']),
+ ('\U0001d76d', &['\u03a8']), ('\U0001d76e', &['\u03a9']), ('\U0001d76f', &['\u2207']),
+ ('\U0001d770', &['\u03b1']), ('\U0001d771', &['\u03b2']), ('\U0001d772', &['\u03b3']),
+ ('\U0001d773', &['\u03b4']), ('\U0001d774', &['\u03b5']), ('\U0001d775', &['\u03b6']),
+ ('\U0001d776', &['\u03b7']), ('\U0001d777', &['\u03b8']), ('\U0001d778', &['\u03b9']),
+ ('\U0001d779', &['\u03ba']), ('\U0001d77a', &['\u03bb']), ('\U0001d77b', &['\u03bc']),
+ ('\U0001d77c', &['\u03bd']), ('\U0001d77d', &['\u03be']), ('\U0001d77e', &['\u03bf']),
+ ('\U0001d77f', &['\u03c0']), ('\U0001d780', &['\u03c1']), ('\U0001d781', &['\u03c2']),
+ ('\U0001d782', &['\u03c3']), ('\U0001d783', &['\u03c4']), ('\U0001d784', &['\u03c5']),
+ ('\U0001d785', &['\u03c6']), ('\U0001d786', &['\u03c7']), ('\U0001d787', &['\u03c8']),
+ ('\U0001d788', &['\u03c9']), ('\U0001d789', &['\u2202']), ('\U0001d78a', &['\u03f5']),
+ ('\U0001d78b', &['\u03d1']), ('\U0001d78c', &['\u03f0']), ('\U0001d78d', &['\u03d5']),
+ ('\U0001d78e', &['\u03f1']), ('\U0001d78f', &['\u03d6']), ('\U0001d790', &['\u0391']),
+ ('\U0001d791', &['\u0392']), ('\U0001d792', &['\u0393']), ('\U0001d793', &['\u0394']),
+ ('\U0001d794', &['\u0395']), ('\U0001d795', &['\u0396']), ('\U0001d796', &['\u0397']),
+ ('\U0001d797', &['\u0398']), ('\U0001d798', &['\u0399']), ('\U0001d799', &['\u039a']),
+ ('\U0001d79a', &['\u039b']), ('\U0001d79b', &['\u039c']), ('\U0001d79c', &['\u039d']),
+ ('\U0001d79d', &['\u039e']), ('\U0001d79e', &['\u039f']), ('\U0001d79f', &['\u03a0']),
+ ('\U0001d7a0', &['\u03a1']), ('\U0001d7a1', &['\u03f4']), ('\U0001d7a2', &['\u03a3']),
+ ('\U0001d7a3', &['\u03a4']), ('\U0001d7a4', &['\u03a5']), ('\U0001d7a5', &['\u03a6']),
+ ('\U0001d7a6', &['\u03a7']), ('\U0001d7a7', &['\u03a8']), ('\U0001d7a8', &['\u03a9']),
+ ('\U0001d7a9', &['\u2207']), ('\U0001d7aa', &['\u03b1']), ('\U0001d7ab', &['\u03b2']),
+ ('\U0001d7ac', &['\u03b3']), ('\U0001d7ad', &['\u03b4']), ('\U0001d7ae', &['\u03b5']),
+ ('\U0001d7af', &['\u03b6']), ('\U0001d7b0', &['\u03b7']), ('\U0001d7b1', &['\u03b8']),
+ ('\U0001d7b2', &['\u03b9']), ('\U0001d7b3', &['\u03ba']), ('\U0001d7b4', &['\u03bb']),
+ ('\U0001d7b5', &['\u03bc']), ('\U0001d7b6', &['\u03bd']), ('\U0001d7b7', &['\u03be']),
+ ('\U0001d7b8', &['\u03bf']), ('\U0001d7b9', &['\u03c0']), ('\U0001d7ba', &['\u03c1']),
+ ('\U0001d7bb', &['\u03c2']), ('\U0001d7bc', &['\u03c3']), ('\U0001d7bd', &['\u03c4']),
+ ('\U0001d7be', &['\u03c5']), ('\U0001d7bf', &['\u03c6']), ('\U0001d7c0', &['\u03c7']),
+ ('\U0001d7c1', &['\u03c8']), ('\U0001d7c2', &['\u03c9']), ('\U0001d7c3', &['\u2202']),
+ ('\U0001d7c4', &['\u03f5']), ('\U0001d7c5', &['\u03d1']), ('\U0001d7c6', &['\u03f0']),
+ ('\U0001d7c7', &['\u03d5']), ('\U0001d7c8', &['\u03f1']), ('\U0001d7c9', &['\u03d6']),
+ ('\U0001d7ca', &['\u03dc']), ('\U0001d7cb', &['\u03dd']), ('\U0001d7ce', &['\x30']),
+ ('\U0001d7cf', &['\x31']), ('\U0001d7d0', &['\x32']), ('\U0001d7d1', &['\x33']),
+ ('\U0001d7d2', &['\x34']), ('\U0001d7d3', &['\x35']), ('\U0001d7d4', &['\x36']),
+ ('\U0001d7d5', &['\x37']), ('\U0001d7d6', &['\x38']), ('\U0001d7d7', &['\x39']),
+ ('\U0001d7d8', &['\x30']), ('\U0001d7d9', &['\x31']), ('\U0001d7da', &['\x32']),
+ ('\U0001d7db', &['\x33']), ('\U0001d7dc', &['\x34']), ('\U0001d7dd', &['\x35']),
+ ('\U0001d7de', &['\x36']), ('\U0001d7df', &['\x37']), ('\U0001d7e0', &['\x38']),
+ ('\U0001d7e1', &['\x39']), ('\U0001d7e2', &['\x30']), ('\U0001d7e3', &['\x31']),
+ ('\U0001d7e4', &['\x32']), ('\U0001d7e5', &['\x33']), ('\U0001d7e6', &['\x34']),
+ ('\U0001d7e7', &['\x35']), ('\U0001d7e8', &['\x36']), ('\U0001d7e9', &['\x37']),
+ ('\U0001d7ea', &['\x38']), ('\U0001d7eb', &['\x39']), ('\U0001d7ec', &['\x30']),
+ ('\U0001d7ed', &['\x31']), ('\U0001d7ee', &['\x32']), ('\U0001d7ef', &['\x33']),
+ ('\U0001d7f0', &['\x34']), ('\U0001d7f1', &['\x35']), ('\U0001d7f2', &['\x36']),
+ ('\U0001d7f3', &['\x37']), ('\U0001d7f4', &['\x38']), ('\U0001d7f5', &['\x39']),
+ ('\U0001d7f6', &['\x30']), ('\U0001d7f7', &['\x31']), ('\U0001d7f8', &['\x32']),
+ ('\U0001d7f9', &['\x33']), ('\U0001d7fa', &['\x34']), ('\U0001d7fb', &['\x35']),
+ ('\U0001d7fc', &['\x36']), ('\U0001d7fd', &['\x37']), ('\U0001d7fe', &['\x38']),
+ ('\U0001d7ff', &['\x39']), ('\U0001ee00', &['\u0627']), ('\U0001ee01', &['\u0628']),
+ ('\U0001ee02', &['\u062c']), ('\U0001ee03', &['\u062f']), ('\U0001ee05', &['\u0648']),
+ ('\U0001ee06', &['\u0632']), ('\U0001ee07', &['\u062d']), ('\U0001ee08', &['\u0637']),
+ ('\U0001ee09', &['\u064a']), ('\U0001ee0a', &['\u0643']), ('\U0001ee0b', &['\u0644']),
+ ('\U0001ee0c', &['\u0645']), ('\U0001ee0d', &['\u0646']), ('\U0001ee0e', &['\u0633']),
+ ('\U0001ee0f', &['\u0639']), ('\U0001ee10', &['\u0641']), ('\U0001ee11', &['\u0635']),
+ ('\U0001ee12', &['\u0642']), ('\U0001ee13', &['\u0631']), ('\U0001ee14', &['\u0634']),
+ ('\U0001ee15', &['\u062a']), ('\U0001ee16', &['\u062b']), ('\U0001ee17', &['\u062e']),
+ ('\U0001ee18', &['\u0630']), ('\U0001ee19', &['\u0636']), ('\U0001ee1a', &['\u0638']),
+ ('\U0001ee1b', &['\u063a']), ('\U0001ee1c', &['\u066e']), ('\U0001ee1d', &['\u06ba']),
+ ('\U0001ee1e', &['\u06a1']), ('\U0001ee1f', &['\u066f']), ('\U0001ee21', &['\u0628']),
+ ('\U0001ee22', &['\u062c']), ('\U0001ee24', &['\u0647']), ('\U0001ee27', &['\u062d']),
+ ('\U0001ee29', &['\u064a']), ('\U0001ee2a', &['\u0643']), ('\U0001ee2b', &['\u0644']),
+ ('\U0001ee2c', &['\u0645']), ('\U0001ee2d', &['\u0646']), ('\U0001ee2e', &['\u0633']),
+ ('\U0001ee2f', &['\u0639']), ('\U0001ee30', &['\u0641']), ('\U0001ee31', &['\u0635']),
+ ('\U0001ee32', &['\u0642']), ('\U0001ee34', &['\u0634']), ('\U0001ee35', &['\u062a']),
+ ('\U0001ee36', &['\u062b']), ('\U0001ee37', &['\u062e']), ('\U0001ee39', &['\u0636']),
+ ('\U0001ee3b', &['\u063a']), ('\U0001ee42', &['\u062c']), ('\U0001ee47', &['\u062d']),
+ ('\U0001ee49', &['\u064a']), ('\U0001ee4b', &['\u0644']), ('\U0001ee4d', &['\u0646']),
+ ('\U0001ee4e', &['\u0633']), ('\U0001ee4f', &['\u0639']), ('\U0001ee51', &['\u0635']),
+ ('\U0001ee52', &['\u0642']), ('\U0001ee54', &['\u0634']), ('\U0001ee57', &['\u062e']),
+ ('\U0001ee59', &['\u0636']), ('\U0001ee5b', &['\u063a']), ('\U0001ee5d', &['\u06ba']),
+ ('\U0001ee5f', &['\u066f']), ('\U0001ee61', &['\u0628']), ('\U0001ee62', &['\u062c']),
+ ('\U0001ee64', &['\u0647']), ('\U0001ee67', &['\u062d']), ('\U0001ee68', &['\u0637']),
+ ('\U0001ee69', &['\u064a']), ('\U0001ee6a', &['\u0643']), ('\U0001ee6c', &['\u0645']),
+ ('\U0001ee6d', &['\u0646']), ('\U0001ee6e', &['\u0633']), ('\U0001ee6f', &['\u0639']),
+ ('\U0001ee70', &['\u0641']), ('\U0001ee71', &['\u0635']), ('\U0001ee72', &['\u0642']),
+ ('\U0001ee74', &['\u0634']), ('\U0001ee75', &['\u062a']), ('\U0001ee76', &['\u062b']),
+ ('\U0001ee77', &['\u062e']), ('\U0001ee79', &['\u0636']), ('\U0001ee7a', &['\u0638']),
+ ('\U0001ee7b', &['\u063a']), ('\U0001ee7c', &['\u066e']), ('\U0001ee7e', &['\u06a1']),
+ ('\U0001ee80', &['\u0627']), ('\U0001ee81', &['\u0628']), ('\U0001ee82', &['\u062c']),
+ ('\U0001ee83', &['\u062f']), ('\U0001ee84', &['\u0647']), ('\U0001ee85', &['\u0648']),
+ ('\U0001ee86', &['\u0632']), ('\U0001ee87', &['\u062d']), ('\U0001ee88', &['\u0637']),
+ ('\U0001ee89', &['\u064a']), ('\U0001ee8b', &['\u0644']), ('\U0001ee8c', &['\u0645']),
+ ('\U0001ee8d', &['\u0646']), ('\U0001ee8e', &['\u0633']), ('\U0001ee8f', &['\u0639']),
+ ('\U0001ee90', &['\u0641']), ('\U0001ee91', &['\u0635']), ('\U0001ee92', &['\u0642']),
+ ('\U0001ee93', &['\u0631']), ('\U0001ee94', &['\u0634']), ('\U0001ee95', &['\u062a']),
+ ('\U0001ee96', &['\u062b']), ('\U0001ee97', &['\u062e']), ('\U0001ee98', &['\u0630']),
+ ('\U0001ee99', &['\u0636']), ('\U0001ee9a', &['\u0638']), ('\U0001ee9b', &['\u063a']),
+ ('\U0001eea1', &['\u0628']), ('\U0001eea2', &['\u062c']), ('\U0001eea3', &['\u062f']),
+ ('\U0001eea5', &['\u0648']), ('\U0001eea6', &['\u0632']), ('\U0001eea7', &['\u062d']),
+ ('\U0001eea8', &['\u0637']), ('\U0001eea9', &['\u064a']), ('\U0001eeab', &['\u0644']),
+ ('\U0001eeac', &['\u0645']), ('\U0001eead', &['\u0646']), ('\U0001eeae', &['\u0633']),
+ ('\U0001eeaf', &['\u0639']), ('\U0001eeb0', &['\u0641']), ('\U0001eeb1', &['\u0635']),
+ ('\U0001eeb2', &['\u0642']), ('\U0001eeb3', &['\u0631']), ('\U0001eeb4', &['\u0634']),
+ ('\U0001eeb5', &['\u062a']), ('\U0001eeb6', &['\u062b']), ('\U0001eeb7', &['\u062e']),
+ ('\U0001eeb8', &['\u0630']), ('\U0001eeb9', &['\u0636']), ('\U0001eeba', &['\u0638']),
+ ('\U0001eebb', &['\u063a']), ('\U0001f100', &['\x30', '\x2e']), ('\U0001f101', &['\x30',
+ '\x2c']), ('\U0001f102', &['\x31', '\x2c']), ('\U0001f103', &['\x32', '\x2c']),
+ ('\U0001f104', &['\x33', '\x2c']), ('\U0001f105', &['\x34', '\x2c']), ('\U0001f106',
+ &['\x35', '\x2c']), ('\U0001f107', &['\x36', '\x2c']), ('\U0001f108', &['\x37', '\x2c']),
+ ('\U0001f109', &['\x38', '\x2c']), ('\U0001f10a', &['\x39', '\x2c']), ('\U0001f110',
+ &['\x28', '\x41', '\x29']), ('\U0001f111', &['\x28', '\x42', '\x29']), ('\U0001f112',
+ &['\x28', '\x43', '\x29']), ('\U0001f113', &['\x28', '\x44', '\x29']), ('\U0001f114',
+ &['\x28', '\x45', '\x29']), ('\U0001f115', &['\x28', '\x46', '\x29']), ('\U0001f116',
+ &['\x28', '\x47', '\x29']), ('\U0001f117', &['\x28', '\x48', '\x29']), ('\U0001f118',
+ &['\x28', '\x49', '\x29']), ('\U0001f119', &['\x28', '\x4a', '\x29']), ('\U0001f11a',
+ &['\x28', '\x4b', '\x29']), ('\U0001f11b', &['\x28', '\x4c', '\x29']), ('\U0001f11c',
+ &['\x28', '\x4d', '\x29']), ('\U0001f11d', &['\x28', '\x4e', '\x29']), ('\U0001f11e',
+ &['\x28', '\x4f', '\x29']), ('\U0001f11f', &['\x28', '\x50', '\x29']), ('\U0001f120',
+ &['\x28', '\x51', '\x29']), ('\U0001f121', &['\x28', '\x52', '\x29']), ('\U0001f122',
+ &['\x28', '\x53', '\x29']), ('\U0001f123', &['\x28', '\x54', '\x29']), ('\U0001f124',
+ &['\x28', '\x55', '\x29']), ('\U0001f125', &['\x28', '\x56', '\x29']), ('\U0001f126',
+ &['\x28', '\x57', '\x29']), ('\U0001f127', &['\x28', '\x58', '\x29']), ('\U0001f128',
+ &['\x28', '\x59', '\x29']), ('\U0001f129', &['\x28', '\x5a', '\x29']), ('\U0001f12a',
+ &['\u3014', '\x53', '\u3015']), ('\U0001f12b', &['\x43']), ('\U0001f12c', &['\x52']),
+ ('\U0001f12d', &['\x43', '\x44']), ('\U0001f12e', &['\x57', '\x5a']), ('\U0001f130',
+ &['\x41']), ('\U0001f131', &['\x42']), ('\U0001f132', &['\x43']), ('\U0001f133', &['\x44']),
+ ('\U0001f134', &['\x45']), ('\U0001f135', &['\x46']), ('\U0001f136', &['\x47']),
+ ('\U0001f137', &['\x48']), ('\U0001f138', &['\x49']), ('\U0001f139', &['\x4a']),
+ ('\U0001f13a', &['\x4b']), ('\U0001f13b', &['\x4c']), ('\U0001f13c', &['\x4d']),
+ ('\U0001f13d', &['\x4e']), ('\U0001f13e', &['\x4f']), ('\U0001f13f', &['\x50']),
+ ('\U0001f140', &['\x51']), ('\U0001f141', &['\x52']), ('\U0001f142', &['\x53']),
+ ('\U0001f143', &['\x54']), ('\U0001f144', &['\x55']), ('\U0001f145', &['\x56']),
+ ('\U0001f146', &['\x57']), ('\U0001f147', &['\x58']), ('\U0001f148', &['\x59']),
+ ('\U0001f149', &['\x5a']), ('\U0001f14a', &['\x48', '\x56']), ('\U0001f14b', &['\x4d',
+ '\x56']), ('\U0001f14c', &['\x53', '\x44']), ('\U0001f14d', &['\x53', '\x53']),
+ ('\U0001f14e', &['\x50', '\x50', '\x56']), ('\U0001f14f', &['\x57', '\x43']), ('\U0001f16a',
+ &['\x4d', '\x43']), ('\U0001f16b', &['\x4d', '\x44']), ('\U0001f190', &['\x44', '\x4a']),
+ ('\U0001f200', &['\u307b', '\u304b']), ('\U0001f201', &['\u30b3', '\u30b3']), ('\U0001f202',
+ &['\u30b5']), ('\U0001f210', &['\u624b']), ('\U0001f211', &['\u5b57']), ('\U0001f212',
+ &['\u53cc']), ('\U0001f213', &['\u30c7']), ('\U0001f214', &['\u4e8c']), ('\U0001f215',
+ &['\u591a']), ('\U0001f216', &['\u89e3']), ('\U0001f217', &['\u5929']), ('\U0001f218',
+ &['\u4ea4']), ('\U0001f219', &['\u6620']), ('\U0001f21a', &['\u7121']), ('\U0001f21b',
+ &['\u6599']), ('\U0001f21c', &['\u524d']), ('\U0001f21d', &['\u5f8c']), ('\U0001f21e',
+ &['\u518d']), ('\U0001f21f', &['\u65b0']), ('\U0001f220', &['\u521d']), ('\U0001f221',
+ &['\u7d42']), ('\U0001f222', &['\u751f']), ('\U0001f223', &['\u8ca9']), ('\U0001f224',
+ &['\u58f0']), ('\U0001f225', &['\u5439']), ('\U0001f226', &['\u6f14']), ('\U0001f227',
+ &['\u6295']), ('\U0001f228', &['\u6355']), ('\U0001f229', &['\u4e00']), ('\U0001f22a',
+ &['\u4e09']), ('\U0001f22b', &['\u904a']), ('\U0001f22c', &['\u5de6']), ('\U0001f22d',
+ &['\u4e2d']), ('\U0001f22e', &['\u53f3']), ('\U0001f22f', &['\u6307']), ('\U0001f230',
+ &['\u8d70']), ('\U0001f231', &['\u6253']), ('\U0001f232', &['\u7981']), ('\U0001f233',
+ &['\u7a7a']), ('\U0001f234', &['\u5408']), ('\U0001f235', &['\u6e80']), ('\U0001f236',
+ &['\u6709']), ('\U0001f237', &['\u6708']), ('\U0001f238', &['\u7533']), ('\U0001f239',
+ &['\u5272']), ('\U0001f23a', &['\u55b6']), ('\U0001f240', &['\u3014', '\u672c', '\u3015']),
+ ('\U0001f241', &['\u3014', '\u4e09', '\u3015']), ('\U0001f242', &['\u3014', '\u4e8c',
+ '\u3015']), ('\U0001f243', &['\u3014', '\u5b89', '\u3015']), ('\U0001f244', &['\u3014',
+ '\u70b9', '\u3015']), ('\U0001f245', &['\u3014', '\u6253', '\u3015']), ('\U0001f246',
+ &['\u3014', '\u76d7', '\u3015']), ('\U0001f247', &['\u3014', '\u52dd', '\u3015']),
+ ('\U0001f248', &['\u3014', '\u6557', '\u3015']), ('\U0001f250', &['\u5f97']), ('\U0001f251',
+ &['\u53ef'])
+ ];
+
+
+ fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
+ use core::option::{Some, None};
+ use core::cmp::{Equal, Less, Greater};
+ use core::slice::ImmutableVector;
+ match r.bsearch(|&(lo, hi, _)| {
+ if lo <= c && c <= hi { Equal }
+ else if hi < c { Less }
+ else { Greater }
+ }) {
+ Some(idx) => {
+ let (_, _, result) = r[idx];
+ result
+ }
+ None => 0
+ }
+ }
+
+ static combining_class_table: &'static [(char, char, u8)] = &[
+ ('\u0300', '\u0314', 230), ('\u0315', '\u0315', 232), ('\u0316', '\u0319', 220), ('\u031a',
+ '\u031a', 232), ('\u031b', '\u031b', 216), ('\u031c', '\u0320', 220), ('\u0321', '\u0322',
+ 202), ('\u0323', '\u0326', 220), ('\u0327', '\u0328', 202), ('\u0329', '\u0333', 220),
+ ('\u0334', '\u0338', 1), ('\u0339', '\u033c', 220), ('\u033d', '\u0344', 230), ('\u0345',
+ '\u0345', 240), ('\u0346', '\u0346', 230), ('\u0347', '\u0349', 220), ('\u034a', '\u034c',
+ 230), ('\u034d', '\u034e', 220), ('\u0350', '\u0352', 230), ('\u0353', '\u0356', 220),
+ ('\u0357', '\u0357', 230), ('\u0358', '\u0358', 232), ('\u0359', '\u035a', 220), ('\u035b',
+ '\u035b', 230), ('\u035c', '\u035c', 233), ('\u035d', '\u035e', 234), ('\u035f', '\u035f',
+ 233), ('\u0360', '\u0361', 234), ('\u0362', '\u0362', 233), ('\u0363', '\u036f', 230),
+ ('\u0483', '\u0487', 230), ('\u0591', '\u0591', 220), ('\u0592', '\u0595', 230), ('\u0596',
+ '\u0596', 220), ('\u0597', '\u0599', 230), ('\u059a', '\u059a', 222), ('\u059b', '\u059b',
+ 220), ('\u059c', '\u05a1', 230), ('\u05a2', '\u05a7', 220), ('\u05a8', '\u05a9', 230),
+ ('\u05aa', '\u05aa', 220), ('\u05ab', '\u05ac', 230), ('\u05ad', '\u05ad', 222), ('\u05ae',
+ '\u05ae', 228), ('\u05af', '\u05af', 230), ('\u05b0', '\u05b0', 10), ('\u05b1', '\u05b1',
+ 11), ('\u05b2', '\u05b2', 12), ('\u05b3', '\u05b3', 13), ('\u05b4', '\u05b4', 14),
+ ('\u05b5', '\u05b5', 15), ('\u05b6', '\u05b6', 16), ('\u05b7', '\u05b7', 17), ('\u05b8',
+ '\u05b8', 18), ('\u05b9', '\u05ba', 19), ('\u05bb', '\u05bb', 20), ('\u05bc', '\u05bc', 21),
+ ('\u05bd', '\u05bd', 22), ('\u05bf', '\u05bf', 23), ('\u05c1', '\u05c1', 24), ('\u05c2',
+ '\u05c2', 25), ('\u05c4', '\u05c4', 230), ('\u05c5', '\u05c5', 220), ('\u05c7', '\u05c7',
+ 18), ('\u0610', '\u0617', 230), ('\u0618', '\u0618', 30), ('\u0619', '\u0619', 31),
+ ('\u061a', '\u061a', 32), ('\u064b', '\u064b', 27), ('\u064c', '\u064c', 28), ('\u064d',
+ '\u064d', 29), ('\u064e', '\u064e', 30), ('\u064f', '\u064f', 31), ('\u0650', '\u0650', 32),
+ ('\u0651', '\u0651', 33), ('\u0652', '\u0652', 34), ('\u0653', '\u0654', 230), ('\u0655',
+ '\u0656', 220), ('\u0657', '\u065b', 230), ('\u065c', '\u065c', 220), ('\u065d', '\u065e',
+ 230), ('\u065f', '\u065f', 220), ('\u0670', '\u0670', 35), ('\u06d6', '\u06dc', 230),
+ ('\u06df', '\u06e2', 230), ('\u06e3', '\u06e3', 220), ('\u06e4', '\u06e4', 230), ('\u06e7',
+ '\u06e8', 230), ('\u06ea', '\u06ea', 220), ('\u06eb', '\u06ec', 230), ('\u06ed', '\u06ed',
+ 220), ('\u0711', '\u0711', 36), ('\u0730', '\u0730', 230), ('\u0731', '\u0731', 220),
+ ('\u0732', '\u0733', 230), ('\u0734', '\u0734', 220), ('\u0735', '\u0736', 230), ('\u0737',
+ '\u0739', 220), ('\u073a', '\u073a', 230), ('\u073b', '\u073c', 220), ('\u073d', '\u073d',
+ 230), ('\u073e', '\u073e', 220), ('\u073f', '\u0741', 230), ('\u0742', '\u0742', 220),
+ ('\u0743', '\u0743', 230), ('\u0744', '\u0744', 220), ('\u0745', '\u0745', 230), ('\u0746',
+ '\u0746', 220), ('\u0747', '\u0747', 230), ('\u0748', '\u0748', 220), ('\u0749', '\u074a',
+ 230), ('\u07eb', '\u07f1', 230), ('\u07f2', '\u07f2', 220), ('\u07f3', '\u07f3', 230),
+ ('\u0816', '\u0819', 230), ('\u081b', '\u0823', 230), ('\u0825', '\u0827', 230), ('\u0829',
+ '\u082d', 230), ('\u0859', '\u085b', 220), ('\u08e4', '\u08e5', 230), ('\u08e6', '\u08e6',
+ 220), ('\u08e7', '\u08e8', 230), ('\u08e9', '\u08e9', 220), ('\u08ea', '\u08ec', 230),
+ ('\u08ed', '\u08ef', 220), ('\u08f0', '\u08f0', 27), ('\u08f1', '\u08f1', 28), ('\u08f2',
+ '\u08f2', 29), ('\u08f3', '\u08f5', 230), ('\u08f6', '\u08f6', 220), ('\u08f7', '\u08f8',
+ 230), ('\u08f9', '\u08fa', 220), ('\u08fb', '\u08ff', 230), ('\u093c', '\u093c', 7),
+ ('\u094d', '\u094d', 9), ('\u0951', '\u0951', 230), ('\u0952', '\u0952', 220), ('\u0953',
+ '\u0954', 230), ('\u09bc', '\u09bc', 7), ('\u09cd', '\u09cd', 9), ('\u0a3c', '\u0a3c', 7),
+ ('\u0a4d', '\u0a4d', 9), ('\u0abc', '\u0abc', 7), ('\u0acd', '\u0acd', 9), ('\u0b3c',
+ '\u0b3c', 7), ('\u0b4d', '\u0b4d', 9), ('\u0bcd', '\u0bcd', 9), ('\u0c4d', '\u0c4d', 9),
+ ('\u0c55', '\u0c55', 84), ('\u0c56', '\u0c56', 91), ('\u0cbc', '\u0cbc', 7), ('\u0ccd',
+ '\u0ccd', 9), ('\u0d4d', '\u0d4d', 9), ('\u0dca', '\u0dca', 9), ('\u0e38', '\u0e39', 103),
+ ('\u0e3a', '\u0e3a', 9), ('\u0e48', '\u0e4b', 107), ('\u0eb8', '\u0eb9', 118), ('\u0ec8',
+ '\u0ecb', 122), ('\u0f18', '\u0f19', 220), ('\u0f35', '\u0f35', 220), ('\u0f37', '\u0f37',
+ 220), ('\u0f39', '\u0f39', 216), ('\u0f71', '\u0f71', 129), ('\u0f72', '\u0f72', 130),
+ ('\u0f74', '\u0f74', 132), ('\u0f7a', '\u0f7d', 130), ('\u0f80', '\u0f80', 130), ('\u0f82',
+ '\u0f83', 230), ('\u0f84', '\u0f84', 9), ('\u0f86', '\u0f87', 230), ('\u0fc6', '\u0fc6',
+ 220), ('\u1037', '\u1037', 7), ('\u1039', '\u103a', 9), ('\u108d', '\u108d', 220),
+ ('\u135d', '\u135f', 230), ('\u1714', '\u1714', 9), ('\u1734', '\u1734', 9), ('\u17d2',
+ '\u17d2', 9), ('\u17dd', '\u17dd', 230), ('\u18a9', '\u18a9', 228), ('\u1939', '\u1939',
+ 222), ('\u193a', '\u193a', 230), ('\u193b', '\u193b', 220), ('\u1a17', '\u1a17', 230),
+ ('\u1a18', '\u1a18', 220), ('\u1a60', '\u1a60', 9), ('\u1a75', '\u1a7c', 230), ('\u1a7f',
+ '\u1a7f', 220), ('\u1ab0', '\u1ab4', 230), ('\u1ab5', '\u1aba', 220), ('\u1abb', '\u1abc',
+ 230), ('\u1abd', '\u1abd', 220), ('\u1b34', '\u1b34', 7), ('\u1b44', '\u1b44', 9),
+ ('\u1b6b', '\u1b6b', 230), ('\u1b6c', '\u1b6c', 220), ('\u1b6d', '\u1b73', 230), ('\u1baa',
+ '\u1bab', 9), ('\u1be6', '\u1be6', 7), ('\u1bf2', '\u1bf3', 9), ('\u1c37', '\u1c37', 7),
+ ('\u1cd0', '\u1cd2', 230), ('\u1cd4', '\u1cd4', 1), ('\u1cd5', '\u1cd9', 220), ('\u1cda',
+ '\u1cdb', 230), ('\u1cdc', '\u1cdf', 220), ('\u1ce0', '\u1ce0', 230), ('\u1ce2', '\u1ce8',
+ 1), ('\u1ced', '\u1ced', 220), ('\u1cf4', '\u1cf4', 230), ('\u1cf8', '\u1cf9', 230),
+ ('\u1dc0', '\u1dc1', 230), ('\u1dc2', '\u1dc2', 220), ('\u1dc3', '\u1dc9', 230), ('\u1dca',
+ '\u1dca', 220), ('\u1dcb', '\u1dcc', 230), ('\u1dcd', '\u1dcd', 234), ('\u1dce', '\u1dce',
+ 214), ('\u1dcf', '\u1dcf', 220), ('\u1dd0', '\u1dd0', 202), ('\u1dd1', '\u1df5', 230),
+ ('\u1dfc', '\u1dfc', 233), ('\u1dfd', '\u1dfd', 220), ('\u1dfe', '\u1dfe', 230), ('\u1dff',
+ '\u1dff', 220), ('\u20d0', '\u20d1', 230), ('\u20d2', '\u20d3', 1), ('\u20d4', '\u20d7',
+ 230), ('\u20d8', '\u20da', 1), ('\u20db', '\u20dc', 230), ('\u20e1', '\u20e1', 230),
+ ('\u20e5', '\u20e6', 1), ('\u20e7', '\u20e7', 230), ('\u20e8', '\u20e8', 220), ('\u20e9',
+ '\u20e9', 230), ('\u20ea', '\u20eb', 1), ('\u20ec', '\u20ef', 220), ('\u20f0', '\u20f0',
+ 230), ('\u2cef', '\u2cf1', 230), ('\u2d7f', '\u2d7f', 9), ('\u2de0', '\u2dff', 230),
+ ('\u302a', '\u302a', 218), ('\u302b', '\u302b', 228), ('\u302c', '\u302c', 232), ('\u302d',
+ '\u302d', 222), ('\u302e', '\u302f', 224), ('\u3099', '\u309a', 8), ('\ua66f', '\ua66f',
+ 230), ('\ua674', '\ua67d', 230), ('\ua69f', '\ua69f', 230), ('\ua6f0', '\ua6f1', 230),
+ ('\ua806', '\ua806', 9), ('\ua8c4', '\ua8c4', 9), ('\ua8e0', '\ua8f1', 230), ('\ua92b',
+ '\ua92d', 220), ('\ua953', '\ua953', 9), ('\ua9b3', '\ua9b3', 7), ('\ua9c0', '\ua9c0', 9),
+ ('\uaab0', '\uaab0', 230), ('\uaab2', '\uaab3', 230), ('\uaab4', '\uaab4', 220), ('\uaab7',
+ '\uaab8', 230), ('\uaabe', '\uaabf', 230), ('\uaac1', '\uaac1', 230), ('\uaaf6', '\uaaf6',
+ 9), ('\uabed', '\uabed', 9), ('\ufb1e', '\ufb1e', 26), ('\ufe20', '\ufe26', 230), ('\ufe27',
+ '\ufe2d', 220), ('\U000101fd', '\U000101fd', 220), ('\U000102e0', '\U000102e0', 220),
+ ('\U00010376', '\U0001037a', 230), ('\U00010a0d', '\U00010a0d', 220), ('\U00010a0f',
+ '\U00010a0f', 230), ('\U00010a38', '\U00010a38', 230), ('\U00010a39', '\U00010a39', 1),
+ ('\U00010a3a', '\U00010a3a', 220), ('\U00010a3f', '\U00010a3f', 9), ('\U00010ae5',
+ '\U00010ae5', 230), ('\U00010ae6', '\U00010ae6', 220), ('\U00011046', '\U00011046', 9),
+ ('\U0001107f', '\U0001107f', 9), ('\U000110b9', '\U000110b9', 9), ('\U000110ba',
+ '\U000110ba', 7), ('\U00011100', '\U00011102', 230), ('\U00011133', '\U00011134', 9),
+ ('\U00011173', '\U00011173', 7), ('\U000111c0', '\U000111c0', 9), ('\U00011235',
+ '\U00011235', 9), ('\U00011236', '\U00011236', 7), ('\U000112e9', '\U000112e9', 7),
+ ('\U000112ea', '\U000112ea', 9), ('\U0001133c', '\U0001133c', 7), ('\U0001134d',
+ '\U0001134d', 9), ('\U00011366', '\U0001136c', 230), ('\U00011370', '\U00011374', 230),
+ ('\U000114c2', '\U000114c2', 9), ('\U000114c3', '\U000114c3', 7), ('\U000115bf',
+ '\U000115bf', 9), ('\U000115c0', '\U000115c0', 7), ('\U0001163f', '\U0001163f', 9),
+ ('\U000116b6', '\U000116b6', 9), ('\U000116b7', '\U000116b7', 7), ('\U00016af0',
+ '\U00016af4', 1), ('\U00016b30', '\U00016b36', 230), ('\U0001bc9e', '\U0001bc9e', 1),
+ ('\U0001d165', '\U0001d166', 216), ('\U0001d167', '\U0001d169', 1), ('\U0001d16d',
+ '\U0001d16d', 226), ('\U0001d16e', '\U0001d172', 216), ('\U0001d17b', '\U0001d182', 220),
+ ('\U0001d185', '\U0001d189', 230), ('\U0001d18a', '\U0001d18b', 220), ('\U0001d1aa',
+ '\U0001d1ad', 230), ('\U0001d242', '\U0001d244', 230), ('\U0001e8d0', '\U0001e8d6', 220)
+ ];
+
+ pub fn canonical_combining_class(c: char) -> u8 {
+ bsearch_range_value_table(c, combining_class_table)
+ }
+
+}
+
+pub mod conversions {
+ use core::cmp::{Equal, Less, Greater};
+ use core::slice::ImmutableVector;
+ use core::tuple::Tuple2;
+ use core::option::{Option, Some, None};
+
+ pub fn to_lower(c: char) -> char {
+ match bsearch_case_table(c, LuLl_table) {
+ None => c,
+ Some(index) => LuLl_table[index].val1()
+ }
+ }
+
+ pub fn to_upper(c: char) -> char {
+ match bsearch_case_table(c, LlLu_table) {
+ None => c,
+ Some(index) => LlLu_table[index].val1()
+ }
+ }
+
+ fn bsearch_case_table(c: char, table: &'static [(char, char)]) -> Option<uint> {
+ table.bsearch(|&(key, _)| {
+ if c == key { Equal }
+ else if key < c { Less }
+ else { Greater }
+ })
+ }
+
+ static LuLl_table: &'static [(char, char)] = &[
+ ('\x41', '\x61'), ('\x42', '\x62'), ('\x43', '\x63'), ('\x44', '\x64'), ('\x45', '\x65'),
+ ('\x46', '\x66'), ('\x47', '\x67'), ('\x48', '\x68'), ('\x49', '\x69'), ('\x4a', '\x6a'),
+ ('\x4b', '\x6b'), ('\x4c', '\x6c'), ('\x4d', '\x6d'), ('\x4e', '\x6e'), ('\x4f', '\x6f'),
+ ('\x50', '\x70'), ('\x51', '\x71'), ('\x52', '\x72'), ('\x53', '\x73'), ('\x54', '\x74'),
+ ('\x55', '\x75'), ('\x56', '\x76'), ('\x57', '\x77'), ('\x58', '\x78'), ('\x59', '\x79'),
+ ('\x5a', '\x7a'), ('\xc0', '\xe0'), ('\xc1', '\xe1'), ('\xc2', '\xe2'), ('\xc3', '\xe3'),
+ ('\xc4', '\xe4'), ('\xc5', '\xe5'), ('\xc6', '\xe6'), ('\xc7', '\xe7'), ('\xc8', '\xe8'),
+ ('\xc9', '\xe9'), ('\xca', '\xea'), ('\xcb', '\xeb'), ('\xcc', '\xec'), ('\xcd', '\xed'),
+ ('\xce', '\xee'), ('\xcf', '\xef'), ('\xd0', '\xf0'), ('\xd1', '\xf1'), ('\xd2', '\xf2'),
+ ('\xd3', '\xf3'), ('\xd4', '\xf4'), ('\xd5', '\xf5'), ('\xd6', '\xf6'), ('\xd8', '\xf8'),
+ ('\xd9', '\xf9'), ('\xda', '\xfa'), ('\xdb', '\xfb'), ('\xdc', '\xfc'), ('\xdd', '\xfd'),
+ ('\xde', '\xfe'), ('\u0100', '\u0101'), ('\u0102', '\u0103'), ('\u0104', '\u0105'),
+ ('\u0106', '\u0107'), ('\u0108', '\u0109'), ('\u010a', '\u010b'), ('\u010c', '\u010d'),
+ ('\u010e', '\u010f'), ('\u0110', '\u0111'), ('\u0112', '\u0113'), ('\u0114', '\u0115'),
+ ('\u0116', '\u0117'), ('\u0118', '\u0119'), ('\u011a', '\u011b'), ('\u011c', '\u011d'),
+ ('\u011e', '\u011f'), ('\u0120', '\u0121'), ('\u0122', '\u0123'), ('\u0124', '\u0125'),
+ ('\u0126', '\u0127'), ('\u0128', '\u0129'), ('\u012a', '\u012b'), ('\u012c', '\u012d'),
+ ('\u012e', '\u012f'), ('\u0130', '\x69'), ('\u0132', '\u0133'), ('\u0134', '\u0135'),
+ ('\u0136', '\u0137'), ('\u0139', '\u013a'), ('\u013b', '\u013c'), ('\u013d', '\u013e'),
+ ('\u013f', '\u0140'), ('\u0141', '\u0142'), ('\u0143', '\u0144'), ('\u0145', '\u0146'),
+ ('\u0147', '\u0148'), ('\u014a', '\u014b'), ('\u014c', '\u014d'), ('\u014e', '\u014f'),
+ ('\u0150', '\u0151'), ('\u0152', '\u0153'), ('\u0154', '\u0155'), ('\u0156', '\u0157'),
+ ('\u0158', '\u0159'), ('\u015a', '\u015b'), ('\u015c', '\u015d'), ('\u015e', '\u015f'),
+ ('\u0160', '\u0161'), ('\u0162', '\u0163'), ('\u0164', '\u0165'), ('\u0166', '\u0167'),
+ ('\u0168', '\u0169'), ('\u016a', '\u016b'), ('\u016c', '\u016d'), ('\u016e', '\u016f'),
+ ('\u0170', '\u0171'), ('\u0172', '\u0173'), ('\u0174', '\u0175'), ('\u0176', '\u0177'),
+ ('\u0178', '\xff'), ('\u0179', '\u017a'), ('\u017b', '\u017c'), ('\u017d', '\u017e'),
+ ('\u0181', '\u0253'), ('\u0182', '\u0183'), ('\u0184', '\u0185'), ('\u0186', '\u0254'),
+ ('\u0187', '\u0188'), ('\u0189', '\u0256'), ('\u018a', '\u0257'), ('\u018b', '\u018c'),
+ ('\u018e', '\u01dd'), ('\u018f', '\u0259'), ('\u0190', '\u025b'), ('\u0191', '\u0192'),
+ ('\u0193', '\u0260'), ('\u0194', '\u0263'), ('\u0196', '\u0269'), ('\u0197', '\u0268'),
+ ('\u0198', '\u0199'), ('\u019c', '\u026f'), ('\u019d', '\u0272'), ('\u019f', '\u0275'),
+ ('\u01a0', '\u01a1'), ('\u01a2', '\u01a3'), ('\u01a4', '\u01a5'), ('\u01a6', '\u0280'),
+ ('\u01a7', '\u01a8'), ('\u01a9', '\u0283'), ('\u01ac', '\u01ad'), ('\u01ae', '\u0288'),
+ ('\u01af', '\u01b0'), ('\u01b1', '\u028a'), ('\u01b2', '\u028b'), ('\u01b3', '\u01b4'),
+ ('\u01b5', '\u01b6'), ('\u01b7', '\u0292'), ('\u01b8', '\u01b9'), ('\u01bc', '\u01bd'),
+ ('\u01c4', '\u01c6'), ('\u01c7', '\u01c9'), ('\u01ca', '\u01cc'), ('\u01cd', '\u01ce'),
+ ('\u01cf', '\u01d0'), ('\u01d1', '\u01d2'), ('\u01d3', '\u01d4'), ('\u01d5', '\u01d6'),
+ ('\u01d7', '\u01d8'), ('\u01d9', '\u01da'), ('\u01db', '\u01dc'), ('\u01de', '\u01df'),
+ ('\u01e0', '\u01e1'), ('\u01e2', '\u01e3'), ('\u01e4', '\u01e5'), ('\u01e6', '\u01e7'),
+ ('\u01e8', '\u01e9'), ('\u01ea', '\u01eb'), ('\u01ec', '\u01ed'), ('\u01ee', '\u01ef'),
+ ('\u01f1', '\u01f3'), ('\u01f4', '\u01f5'), ('\u01f6', '\u0195'), ('\u01f7', '\u01bf'),
+ ('\u01f8', '\u01f9'), ('\u01fa', '\u01fb'), ('\u01fc', '\u01fd'), ('\u01fe', '\u01ff'),
+ ('\u0200', '\u0201'), ('\u0202', '\u0203'), ('\u0204', '\u0205'), ('\u0206', '\u0207'),
+ ('\u0208', '\u0209'), ('\u020a', '\u020b'), ('\u020c', '\u020d'), ('\u020e', '\u020f'),
+ ('\u0210', '\u0211'), ('\u0212', '\u0213'), ('\u0214', '\u0215'), ('\u0216', '\u0217'),
+ ('\u0218', '\u0219'), ('\u021a', '\u021b'), ('\u021c', '\u021d'), ('\u021e', '\u021f'),
+ ('\u0220', '\u019e'), ('\u0222', '\u0223'), ('\u0224', '\u0225'), ('\u0226', '\u0227'),
+ ('\u0228', '\u0229'), ('\u022a', '\u022b'), ('\u022c', '\u022d'), ('\u022e', '\u022f'),
+ ('\u0230', '\u0231'), ('\u0232', '\u0233'), ('\u023a', '\u2c65'), ('\u023b', '\u023c'),
+ ('\u023d', '\u019a'), ('\u023e', '\u2c66'), ('\u0241', '\u0242'), ('\u0243', '\u0180'),
+ ('\u0244', '\u0289'), ('\u0245', '\u028c'), ('\u0246', '\u0247'), ('\u0248', '\u0249'),
+ ('\u024a', '\u024b'), ('\u024c', '\u024d'), ('\u024e', '\u024f'), ('\u0370', '\u0371'),
+ ('\u0372', '\u0373'), ('\u0376', '\u0377'), ('\u037f', '\u03f3'), ('\u0386', '\u03ac'),
+ ('\u0388', '\u03ad'), ('\u0389', '\u03ae'), ('\u038a', '\u03af'), ('\u038c', '\u03cc'),
+ ('\u038e', '\u03cd'), ('\u038f', '\u03ce'), ('\u0391', '\u03b1'), ('\u0392', '\u03b2'),
+ ('\u0393', '\u03b3'), ('\u0394', '\u03b4'), ('\u0395', '\u03b5'), ('\u0396', '\u03b6'),
+ ('\u0397', '\u03b7'), ('\u0398', '\u03b8'), ('\u0399', '\u03b9'), ('\u039a', '\u03ba'),
+ ('\u039b', '\u03bb'), ('\u039c', '\u03bc'), ('\u039d', '\u03bd'), ('\u039e', '\u03be'),
+ ('\u039f', '\u03bf'), ('\u03a0', '\u03c0'), ('\u03a1', '\u03c1'), ('\u03a3', '\u03c3'),
+ ('\u03a4', '\u03c4'), ('\u03a5', '\u03c5'), ('\u03a6', '\u03c6'), ('\u03a7', '\u03c7'),
+ ('\u03a8', '\u03c8'), ('\u03a9', '\u03c9'), ('\u03aa', '\u03ca'), ('\u03ab', '\u03cb'),
+ ('\u03cf', '\u03d7'), ('\u03d8', '\u03d9'), ('\u03da', '\u03db'), ('\u03dc', '\u03dd'),
+ ('\u03de', '\u03df'), ('\u03e0', '\u03e1'), ('\u03e2', '\u03e3'), ('\u03e4', '\u03e5'),
+ ('\u03e6', '\u03e7'), ('\u03e8', '\u03e9'), ('\u03ea', '\u03eb'), ('\u03ec', '\u03ed'),
+ ('\u03ee', '\u03ef'), ('\u03f4', '\u03b8'), ('\u03f7', '\u03f8'), ('\u03f9', '\u03f2'),
+ ('\u03fa', '\u03fb'), ('\u03fd', '\u037b'), ('\u03fe', '\u037c'), ('\u03ff', '\u037d'),
+ ('\u0400', '\u0450'), ('\u0401', '\u0451'), ('\u0402', '\u0452'), ('\u0403', '\u0453'),
+ ('\u0404', '\u0454'), ('\u0405', '\u0455'), ('\u0406', '\u0456'), ('\u0407', '\u0457'),
+ ('\u0408', '\u0458'), ('\u0409', '\u0459'), ('\u040a', '\u045a'), ('\u040b', '\u045b'),
+ ('\u040c', '\u045c'), ('\u040d', '\u045d'), ('\u040e', '\u045e'), ('\u040f', '\u045f'),
+ ('\u0410', '\u0430'), ('\u0411', '\u0431'), ('\u0412', '\u0432'), ('\u0413', '\u0433'),
+ ('\u0414', '\u0434'), ('\u0415', '\u0435'), ('\u0416', '\u0436'), ('\u0417', '\u0437'),
+ ('\u0418', '\u0438'), ('\u0419', '\u0439'), ('\u041a', '\u043a'), ('\u041b', '\u043b'),
+ ('\u041c', '\u043c'), ('\u041d', '\u043d'), ('\u041e', '\u043e'), ('\u041f', '\u043f'),
+ ('\u0420', '\u0440'), ('\u0421', '\u0441'), ('\u0422', '\u0442'), ('\u0423', '\u0443'),
+ ('\u0424', '\u0444'), ('\u0425', '\u0445'), ('\u0426', '\u0446'), ('\u0427', '\u0447'),
+ ('\u0428', '\u0448'), ('\u0429', '\u0449'), ('\u042a', '\u044a'), ('\u042b', '\u044b'),
+ ('\u042c', '\u044c'), ('\u042d', '\u044d'), ('\u042e', '\u044e'), ('\u042f', '\u044f'),
+ ('\u0460', '\u0461'), ('\u0462', '\u0463'), ('\u0464', '\u0465'), ('\u0466', '\u0467'),
+ ('\u0468', '\u0469'), ('\u046a', '\u046b'), ('\u046c', '\u046d'), ('\u046e', '\u046f'),
+ ('\u0470', '\u0471'), ('\u0472', '\u0473'), ('\u0474', '\u0475'), ('\u0476', '\u0477'),
+ ('\u0478', '\u0479'), ('\u047a', '\u047b'), ('\u047c', '\u047d'), ('\u047e', '\u047f'),
+ ('\u0480', '\u0481'), ('\u048a', '\u048b'), ('\u048c', '\u048d'), ('\u048e', '\u048f'),
+ ('\u0490', '\u0491'), ('\u0492', '\u0493'), ('\u0494', '\u0495'), ('\u0496', '\u0497'),
+ ('\u0498', '\u0499'), ('\u049a', '\u049b'), ('\u049c', '\u049d'), ('\u049e', '\u049f'),
+ ('\u04a0', '\u04a1'), ('\u04a2', '\u04a3'), ('\u04a4', '\u04a5'), ('\u04a6', '\u04a7'),
+ ('\u04a8', '\u04a9'), ('\u04aa', '\u04ab'), ('\u04ac', '\u04ad'), ('\u04ae', '\u04af'),
+ ('\u04b0', '\u04b1'), ('\u04b2', '\u04b3'), ('\u04b4', '\u04b5'), ('\u04b6', '\u04b7'),
+ ('\u04b8', '\u04b9'), ('\u04ba', '\u04bb'), ('\u04bc', '\u04bd'), ('\u04be', '\u04bf'),
+ ('\u04c0', '\u04cf'), ('\u04c1', '\u04c2'), ('\u04c3', '\u04c4'), ('\u04c5', '\u04c6'),
+ ('\u04c7', '\u04c8'), ('\u04c9', '\u04ca'), ('\u04cb', '\u04cc'), ('\u04cd', '\u04ce'),
+ ('\u04d0', '\u04d1'), ('\u04d2', '\u04d3'), ('\u04d4', '\u04d5'), ('\u04d6', '\u04d7'),
+ ('\u04d8', '\u04d9'), ('\u04da', '\u04db'), ('\u04dc', '\u04dd'), ('\u04de', '\u04df'),
+ ('\u04e0', '\u04e1'), ('\u04e2', '\u04e3'), ('\u04e4', '\u04e5'), ('\u04e6', '\u04e7'),
+ ('\u04e8', '\u04e9'), ('\u04ea', '\u04eb'), ('\u04ec', '\u04ed'), ('\u04ee', '\u04ef'),
+ ('\u04f0', '\u04f1'), ('\u04f2', '\u04f3'), ('\u04f4', '\u04f5'), ('\u04f6', '\u04f7'),
+ ('\u04f8', '\u04f9'), ('\u04fa', '\u04fb'), ('\u04fc', '\u04fd'), ('\u04fe', '\u04ff'),
+ ('\u0500', '\u0501'), ('\u0502', '\u0503'), ('\u0504', '\u0505'), ('\u0506', '\u0507'),
+ ('\u0508', '\u0509'), ('\u050a', '\u050b'), ('\u050c', '\u050d'), ('\u050e', '\u050f'),
+ ('\u0510', '\u0511'), ('\u0512', '\u0513'), ('\u0514', '\u0515'), ('\u0516', '\u0517'),
+ ('\u0518', '\u0519'), ('\u051a', '\u051b'), ('\u051c', '\u051d'), ('\u051e', '\u051f'),
+ ('\u0520', '\u0521'), ('\u0522', '\u0523'), ('\u0524', '\u0525'), ('\u0526', '\u0527'),
+ ('\u0528', '\u0529'), ('\u052a', '\u052b'), ('\u052c', '\u052d'), ('\u052e', '\u052f'),
+ ('\u0531', '\u0561'), ('\u0532', '\u0562'), ('\u0533', '\u0563'), ('\u0534', '\u0564'),
+ ('\u0535', '\u0565'), ('\u0536', '\u0566'), ('\u0537', '\u0567'), ('\u0538', '\u0568'),
+ ('\u0539', '\u0569'), ('\u053a', '\u056a'), ('\u053b', '\u056b'), ('\u053c', '\u056c'),
+ ('\u053d', '\u056d'), ('\u053e', '\u056e'), ('\u053f', '\u056f'), ('\u0540', '\u0570'),
+ ('\u0541', '\u0571'), ('\u0542', '\u0572'), ('\u0543', '\u0573'), ('\u0544', '\u0574'),
+ ('\u0545', '\u0575'), ('\u0546', '\u0576'), ('\u0547', '\u0577'), ('\u0548', '\u0578'),
+ ('\u0549', '\u0579'), ('\u054a', '\u057a'), ('\u054b', '\u057b'), ('\u054c', '\u057c'),
+ ('\u054d', '\u057d'), ('\u054e', '\u057e'), ('\u054f', '\u057f'), ('\u0550', '\u0580'),
+ ('\u0551', '\u0581'), ('\u0552', '\u0582'), ('\u0553', '\u0583'), ('\u0554', '\u0584'),
+ ('\u0555', '\u0585'), ('\u0556', '\u0586'), ('\u10a0', '\u2d00'), ('\u10a1', '\u2d01'),
+ ('\u10a2', '\u2d02'), ('\u10a3', '\u2d03'), ('\u10a4', '\u2d04'), ('\u10a5', '\u2d05'),
+ ('\u10a6', '\u2d06'), ('\u10a7', '\u2d07'), ('\u10a8', '\u2d08'), ('\u10a9', '\u2d09'),
+ ('\u10aa', '\u2d0a'), ('\u10ab', '\u2d0b'), ('\u10ac', '\u2d0c'), ('\u10ad', '\u2d0d'),
+ ('\u10ae', '\u2d0e'), ('\u10af', '\u2d0f'), ('\u10b0', '\u2d10'), ('\u10b1', '\u2d11'),
+ ('\u10b2', '\u2d12'), ('\u10b3', '\u2d13'), ('\u10b4', '\u2d14'), ('\u10b5', '\u2d15'),
+ ('\u10b6', '\u2d16'), ('\u10b7', '\u2d17'), ('\u10b8', '\u2d18'), ('\u10b9', '\u2d19'),
+ ('\u10ba', '\u2d1a'), ('\u10bb', '\u2d1b'), ('\u10bc', '\u2d1c'), ('\u10bd', '\u2d1d'),
+ ('\u10be', '\u2d1e'), ('\u10bf', '\u2d1f'), ('\u10c0', '\u2d20'), ('\u10c1', '\u2d21'),
+ ('\u10c2', '\u2d22'), ('\u10c3', '\u2d23'), ('\u10c4', '\u2d24'), ('\u10c5', '\u2d25'),
+ ('\u10c7', '\u2d27'), ('\u10cd', '\u2d2d'), ('\u1e00', '\u1e01'), ('\u1e02', '\u1e03'),
+ ('\u1e04', '\u1e05'), ('\u1e06', '\u1e07'), ('\u1e08', '\u1e09'), ('\u1e0a', '\u1e0b'),
+ ('\u1e0c', '\u1e0d'), ('\u1e0e', '\u1e0f'), ('\u1e10', '\u1e11'), ('\u1e12', '\u1e13'),
+ ('\u1e14', '\u1e15'), ('\u1e16', '\u1e17'), ('\u1e18', '\u1e19'), ('\u1e1a', '\u1e1b'),
+ ('\u1e1c', '\u1e1d'), ('\u1e1e', '\u1e1f'), ('\u1e20', '\u1e21'), ('\u1e22', '\u1e23'),
+ ('\u1e24', '\u1e25'), ('\u1e26', '\u1e27'), ('\u1e28', '\u1e29'), ('\u1e2a', '\u1e2b'),
+ ('\u1e2c', '\u1e2d'), ('\u1e2e', '\u1e2f'), ('\u1e30', '\u1e31'), ('\u1e32', '\u1e33'),
+ ('\u1e34', '\u1e35'), ('\u1e36', '\u1e37'), ('\u1e38', '\u1e39'), ('\u1e3a', '\u1e3b'),
+ ('\u1e3c', '\u1e3d'), ('\u1e3e', '\u1e3f'), ('\u1e40', '\u1e41'), ('\u1e42', '\u1e43'),
+ ('\u1e44', '\u1e45'), ('\u1e46', '\u1e47'), ('\u1e48', '\u1e49'), ('\u1e4a', '\u1e4b'),
+ ('\u1e4c', '\u1e4d'), ('\u1e4e', '\u1e4f'), ('\u1e50', '\u1e51'), ('\u1e52', '\u1e53'),
+ ('\u1e54', '\u1e55'), ('\u1e56', '\u1e57'), ('\u1e58', '\u1e59'), ('\u1e5a', '\u1e5b'),
+ ('\u1e5c', '\u1e5d'), ('\u1e5e', '\u1e5f'), ('\u1e60', '\u1e61'), ('\u1e62', '\u1e63'),
+ ('\u1e64', '\u1e65'), ('\u1e66', '\u1e67'), ('\u1e68', '\u1e69'), ('\u1e6a', '\u1e6b'),
+ ('\u1e6c', '\u1e6d'), ('\u1e6e', '\u1e6f'), ('\u1e70', '\u1e71'), ('\u1e72', '\u1e73'),
+ ('\u1e74', '\u1e75'), ('\u1e76', '\u1e77'), ('\u1e78', '\u1e79'), ('\u1e7a', '\u1e7b'),
+ ('\u1e7c', '\u1e7d'), ('\u1e7e', '\u1e7f'), ('\u1e80', '\u1e81'), ('\u1e82', '\u1e83'),
+ ('\u1e84', '\u1e85'), ('\u1e86', '\u1e87'), ('\u1e88', '\u1e89'), ('\u1e8a', '\u1e8b'),
+ ('\u1e8c', '\u1e8d'), ('\u1e8e', '\u1e8f'), ('\u1e90', '\u1e91'), ('\u1e92', '\u1e93'),
+ ('\u1e94', '\u1e95'), ('\u1e9e', '\xdf'), ('\u1ea0', '\u1ea1'), ('\u1ea2', '\u1ea3'),
+ ('\u1ea4', '\u1ea5'), ('\u1ea6', '\u1ea7'), ('\u1ea8', '\u1ea9'), ('\u1eaa', '\u1eab'),
+ ('\u1eac', '\u1ead'), ('\u1eae', '\u1eaf'), ('\u1eb0', '\u1eb1'), ('\u1eb2', '\u1eb3'),
+ ('\u1eb4', '\u1eb5'), ('\u1eb6', '\u1eb7'), ('\u1eb8', '\u1eb9'), ('\u1eba', '\u1ebb'),
+ ('\u1ebc', '\u1ebd'), ('\u1ebe', '\u1ebf'), ('\u1ec0', '\u1ec1'), ('\u1ec2', '\u1ec3'),
+ ('\u1ec4', '\u1ec5'), ('\u1ec6', '\u1ec7'), ('\u1ec8', '\u1ec9'), ('\u1eca', '\u1ecb'),
+ ('\u1ecc', '\u1ecd'), ('\u1ece', '\u1ecf'), ('\u1ed0', '\u1ed1'), ('\u1ed2', '\u1ed3'),
+ ('\u1ed4', '\u1ed5'), ('\u1ed6', '\u1ed7'), ('\u1ed8', '\u1ed9'), ('\u1eda', '\u1edb'),
+ ('\u1edc', '\u1edd'), ('\u1ede', '\u1edf'), ('\u1ee0', '\u1ee1'), ('\u1ee2', '\u1ee3'),
+ ('\u1ee4', '\u1ee5'), ('\u1ee6', '\u1ee7'), ('\u1ee8', '\u1ee9'), ('\u1eea', '\u1eeb'),
+ ('\u1eec', '\u1eed'), ('\u1eee', '\u1eef'), ('\u1ef0', '\u1ef1'), ('\u1ef2', '\u1ef3'),
+ ('\u1ef4', '\u1ef5'), ('\u1ef6', '\u1ef7'), ('\u1ef8', '\u1ef9'), ('\u1efa', '\u1efb'),
+ ('\u1efc', '\u1efd'), ('\u1efe', '\u1eff'), ('\u1f08', '\u1f00'), ('\u1f09', '\u1f01'),
+ ('\u1f0a', '\u1f02'), ('\u1f0b', '\u1f03'), ('\u1f0c', '\u1f04'), ('\u1f0d', '\u1f05'),
+ ('\u1f0e', '\u1f06'), ('\u1f0f', '\u1f07'), ('\u1f18', '\u1f10'), ('\u1f19', '\u1f11'),
+ ('\u1f1a', '\u1f12'), ('\u1f1b', '\u1f13'), ('\u1f1c', '\u1f14'), ('\u1f1d', '\u1f15'),
+ ('\u1f28', '\u1f20'), ('\u1f29', '\u1f21'), ('\u1f2a', '\u1f22'), ('\u1f2b', '\u1f23'),
+ ('\u1f2c', '\u1f24'), ('\u1f2d', '\u1f25'), ('\u1f2e', '\u1f26'), ('\u1f2f', '\u1f27'),
+ ('\u1f38', '\u1f30'), ('\u1f39', '\u1f31'), ('\u1f3a', '\u1f32'), ('\u1f3b', '\u1f33'),
+ ('\u1f3c', '\u1f34'), ('\u1f3d', '\u1f35'), ('\u1f3e', '\u1f36'), ('\u1f3f', '\u1f37'),
+ ('\u1f48', '\u1f40'), ('\u1f49', '\u1f41'), ('\u1f4a', '\u1f42'), ('\u1f4b', '\u1f43'),
+ ('\u1f4c', '\u1f44'), ('\u1f4d', '\u1f45'), ('\u1f59', '\u1f51'), ('\u1f5b', '\u1f53'),
+ ('\u1f5d', '\u1f55'), ('\u1f5f', '\u1f57'), ('\u1f68', '\u1f60'), ('\u1f69', '\u1f61'),
+ ('\u1f6a', '\u1f62'), ('\u1f6b', '\u1f63'), ('\u1f6c', '\u1f64'), ('\u1f6d', '\u1f65'),
+ ('\u1f6e', '\u1f66'), ('\u1f6f', '\u1f67'), ('\u1fb8', '\u1fb0'), ('\u1fb9', '\u1fb1'),
+ ('\u1fba', '\u1f70'), ('\u1fbb', '\u1f71'), ('\u1fc8', '\u1f72'), ('\u1fc9', '\u1f73'),
+ ('\u1fca', '\u1f74'), ('\u1fcb', '\u1f75'), ('\u1fd8', '\u1fd0'), ('\u1fd9', '\u1fd1'),
+ ('\u1fda', '\u1f76'), ('\u1fdb', '\u1f77'), ('\u1fe8', '\u1fe0'), ('\u1fe9', '\u1fe1'),
+ ('\u1fea', '\u1f7a'), ('\u1feb', '\u1f7b'), ('\u1fec', '\u1fe5'), ('\u1ff8', '\u1f78'),
+ ('\u1ff9', '\u1f79'), ('\u1ffa', '\u1f7c'), ('\u1ffb', '\u1f7d'), ('\u2126', '\u03c9'),
+ ('\u212a', '\x6b'), ('\u212b', '\xe5'), ('\u2132', '\u214e'), ('\u2183', '\u2184'),
+ ('\u2c00', '\u2c30'), ('\u2c01', '\u2c31'), ('\u2c02', '\u2c32'), ('\u2c03', '\u2c33'),
+ ('\u2c04', '\u2c34'), ('\u2c05', '\u2c35'), ('\u2c06', '\u2c36'), ('\u2c07', '\u2c37'),
+ ('\u2c08', '\u2c38'), ('\u2c09', '\u2c39'), ('\u2c0a', '\u2c3a'), ('\u2c0b', '\u2c3b'),
+ ('\u2c0c', '\u2c3c'), ('\u2c0d', '\u2c3d'), ('\u2c0e', '\u2c3e'), ('\u2c0f', '\u2c3f'),
+ ('\u2c10', '\u2c40'), ('\u2c11', '\u2c41'), ('\u2c12', '\u2c42'), ('\u2c13', '\u2c43'),
+ ('\u2c14', '\u2c44'), ('\u2c15', '\u2c45'), ('\u2c16', '\u2c46'), ('\u2c17', '\u2c47'),
+ ('\u2c18', '\u2c48'), ('\u2c19', '\u2c49'), ('\u2c1a', '\u2c4a'), ('\u2c1b', '\u2c4b'),
+ ('\u2c1c', '\u2c4c'), ('\u2c1d', '\u2c4d'), ('\u2c1e', '\u2c4e'), ('\u2c1f', '\u2c4f'),
+ ('\u2c20', '\u2c50'), ('\u2c21', '\u2c51'), ('\u2c22', '\u2c52'), ('\u2c23', '\u2c53'),
+ ('\u2c24', '\u2c54'), ('\u2c25', '\u2c55'), ('\u2c26', '\u2c56'), ('\u2c27', '\u2c57'),
+ ('\u2c28', '\u2c58'), ('\u2c29', '\u2c59'), ('\u2c2a', '\u2c5a'), ('\u2c2b', '\u2c5b'),
+ ('\u2c2c', '\u2c5c'), ('\u2c2d', '\u2c5d'), ('\u2c2e', '\u2c5e'), ('\u2c60', '\u2c61'),
+ ('\u2c62', '\u026b'), ('\u2c63', '\u1d7d'), ('\u2c64', '\u027d'), ('\u2c67', '\u2c68'),
+ ('\u2c69', '\u2c6a'), ('\u2c6b', '\u2c6c'), ('\u2c6d', '\u0251'), ('\u2c6e', '\u0271'),
+ ('\u2c6f', '\u0250'), ('\u2c70', '\u0252'), ('\u2c72', '\u2c73'), ('\u2c75', '\u2c76'),
+ ('\u2c7e', '\u023f'), ('\u2c7f', '\u0240'), ('\u2c80', '\u2c81'), ('\u2c82', '\u2c83'),
+ ('\u2c84', '\u2c85'), ('\u2c86', '\u2c87'), ('\u2c88', '\u2c89'), ('\u2c8a', '\u2c8b'),
+ ('\u2c8c', '\u2c8d'), ('\u2c8e', '\u2c8f'), ('\u2c90', '\u2c91'), ('\u2c92', '\u2c93'),
+ ('\u2c94', '\u2c95'), ('\u2c96', '\u2c97'), ('\u2c98', '\u2c99'), ('\u2c9a', '\u2c9b'),
+ ('\u2c9c', '\u2c9d'), ('\u2c9e', '\u2c9f'), ('\u2ca0', '\u2ca1'), ('\u2ca2', '\u2ca3'),
+ ('\u2ca4', '\u2ca5'), ('\u2ca6', '\u2ca7'), ('\u2ca8', '\u2ca9'), ('\u2caa', '\u2cab'),
+ ('\u2cac', '\u2cad'), ('\u2cae', '\u2caf'), ('\u2cb0', '\u2cb1'), ('\u2cb2', '\u2cb3'),
+ ('\u2cb4', '\u2cb5'), ('\u2cb6', '\u2cb7'), ('\u2cb8', '\u2cb9'), ('\u2cba', '\u2cbb'),
+ ('\u2cbc', '\u2cbd'), ('\u2cbe', '\u2cbf'), ('\u2cc0', '\u2cc1'), ('\u2cc2', '\u2cc3'),
+ ('\u2cc4', '\u2cc5'), ('\u2cc6', '\u2cc7'), ('\u2cc8', '\u2cc9'), ('\u2cca', '\u2ccb'),
+ ('\u2ccc', '\u2ccd'), ('\u2cce', '\u2ccf'), ('\u2cd0', '\u2cd1'), ('\u2cd2', '\u2cd3'),
+ ('\u2cd4', '\u2cd5'), ('\u2cd6', '\u2cd7'), ('\u2cd8', '\u2cd9'), ('\u2cda', '\u2cdb'),
+ ('\u2cdc', '\u2cdd'), ('\u2cde', '\u2cdf'), ('\u2ce0', '\u2ce1'), ('\u2ce2', '\u2ce3'),
+ ('\u2ceb', '\u2cec'), ('\u2ced', '\u2cee'), ('\u2cf2', '\u2cf3'), ('\ua640', '\ua641'),
+ ('\ua642', '\ua643'), ('\ua644', '\ua645'), ('\ua646', '\ua647'), ('\ua648', '\ua649'),
+ ('\ua64a', '\ua64b'), ('\ua64c', '\ua64d'), ('\ua64e', '\ua64f'), ('\ua650', '\ua651'),
+ ('\ua652', '\ua653'), ('\ua654', '\ua655'), ('\ua656', '\ua657'), ('\ua658', '\ua659'),
+ ('\ua65a', '\ua65b'), ('\ua65c', '\ua65d'), ('\ua65e', '\ua65f'), ('\ua660', '\ua661'),
+ ('\ua662', '\ua663'), ('\ua664', '\ua665'), ('\ua666', '\ua667'), ('\ua668', '\ua669'),
+ ('\ua66a', '\ua66b'), ('\ua66c', '\ua66d'), ('\ua680', '\ua681'), ('\ua682', '\ua683'),
+ ('\ua684', '\ua685'), ('\ua686', '\ua687'), ('\ua688', '\ua689'), ('\ua68a', '\ua68b'),
+ ('\ua68c', '\ua68d'), ('\ua68e', '\ua68f'), ('\ua690', '\ua691'), ('\ua692', '\ua693'),
+ ('\ua694', '\ua695'), ('\ua696', '\ua697'), ('\ua698', '\ua699'), ('\ua69a', '\ua69b'),
+ ('\ua722', '\ua723'), ('\ua724', '\ua725'), ('\ua726', '\ua727'), ('\ua728', '\ua729'),
+ ('\ua72a', '\ua72b'), ('\ua72c', '\ua72d'), ('\ua72e', '\ua72f'), ('\ua732', '\ua733'),
+ ('\ua734', '\ua735'), ('\ua736', '\ua737'), ('\ua738', '\ua739'), ('\ua73a', '\ua73b'),
+ ('\ua73c', '\ua73d'), ('\ua73e', '\ua73f'), ('\ua740', '\ua741'), ('\ua742', '\ua743'),
+ ('\ua744', '\ua745'), ('\ua746', '\ua747'), ('\ua748', '\ua749'), ('\ua74a', '\ua74b'),
+ ('\ua74c', '\ua74d'), ('\ua74e', '\ua74f'), ('\ua750', '\ua751'), ('\ua752', '\ua753'),
+ ('\ua754', '\ua755'), ('\ua756', '\ua757'), ('\ua758', '\ua759'), ('\ua75a', '\ua75b'),
+ ('\ua75c', '\ua75d'), ('\ua75e', '\ua75f'), ('\ua760', '\ua761'), ('\ua762', '\ua763'),
+ ('\ua764', '\ua765'), ('\ua766', '\ua767'), ('\ua768', '\ua769'), ('\ua76a', '\ua76b'),
+ ('\ua76c', '\ua76d'), ('\ua76e', '\ua76f'), ('\ua779', '\ua77a'), ('\ua77b', '\ua77c'),
+ ('\ua77d', '\u1d79'), ('\ua77e', '\ua77f'), ('\ua780', '\ua781'), ('\ua782', '\ua783'),
+ ('\ua784', '\ua785'), ('\ua786', '\ua787'), ('\ua78b', '\ua78c'), ('\ua78d', '\u0265'),
+ ('\ua790', '\ua791'), ('\ua792', '\ua793'), ('\ua796', '\ua797'), ('\ua798', '\ua799'),
+ ('\ua79a', '\ua79b'), ('\ua79c', '\ua79d'), ('\ua79e', '\ua79f'), ('\ua7a0', '\ua7a1'),
+ ('\ua7a2', '\ua7a3'), ('\ua7a4', '\ua7a5'), ('\ua7a6', '\ua7a7'), ('\ua7a8', '\ua7a9'),
+ ('\ua7aa', '\u0266'), ('\ua7ab', '\u025c'), ('\ua7ac', '\u0261'), ('\ua7ad', '\u026c'),
+ ('\ua7b0', '\u029e'), ('\ua7b1', '\u0287'), ('\uff21', '\uff41'), ('\uff22', '\uff42'),
+ ('\uff23', '\uff43'), ('\uff24', '\uff44'), ('\uff25', '\uff45'), ('\uff26', '\uff46'),
+ ('\uff27', '\uff47'), ('\uff28', '\uff48'), ('\uff29', '\uff49'), ('\uff2a', '\uff4a'),
+ ('\uff2b', '\uff4b'), ('\uff2c', '\uff4c'), ('\uff2d', '\uff4d'), ('\uff2e', '\uff4e'),
+ ('\uff2f', '\uff4f'), ('\uff30', '\uff50'), ('\uff31', '\uff51'), ('\uff32', '\uff52'),
+ ('\uff33', '\uff53'), ('\uff34', '\uff54'), ('\uff35', '\uff55'), ('\uff36', '\uff56'),
+ ('\uff37', '\uff57'), ('\uff38', '\uff58'), ('\uff39', '\uff59'), ('\uff3a', '\uff5a'),
+ ('\U00010400', '\U00010428'), ('\U00010401', '\U00010429'), ('\U00010402', '\U0001042a'),
+ ('\U00010403', '\U0001042b'), ('\U00010404', '\U0001042c'), ('\U00010405', '\U0001042d'),
+ ('\U00010406', '\U0001042e'), ('\U00010407', '\U0001042f'), ('\U00010408', '\U00010430'),
+ ('\U00010409', '\U00010431'), ('\U0001040a', '\U00010432'), ('\U0001040b', '\U00010433'),
+ ('\U0001040c', '\U00010434'), ('\U0001040d', '\U00010435'), ('\U0001040e', '\U00010436'),
+ ('\U0001040f', '\U00010437'), ('\U00010410', '\U00010438'), ('\U00010411', '\U00010439'),
+ ('\U00010412', '\U0001043a'), ('\U00010413', '\U0001043b'), ('\U00010414', '\U0001043c'),
+ ('\U00010415', '\U0001043d'), ('\U00010416', '\U0001043e'), ('\U00010417', '\U0001043f'),
+ ('\U00010418', '\U00010440'), ('\U00010419', '\U00010441'), ('\U0001041a', '\U00010442'),
+ ('\U0001041b', '\U00010443'), ('\U0001041c', '\U00010444'), ('\U0001041d', '\U00010445'),
+ ('\U0001041e', '\U00010446'), ('\U0001041f', '\U00010447'), ('\U00010420', '\U00010448'),
+ ('\U00010421', '\U00010449'), ('\U00010422', '\U0001044a'), ('\U00010423', '\U0001044b'),
+ ('\U00010424', '\U0001044c'), ('\U00010425', '\U0001044d'), ('\U00010426', '\U0001044e'),
+ ('\U00010427', '\U0001044f'), ('\U000118a0', '\U000118c0'), ('\U000118a1', '\U000118c1'),
+ ('\U000118a2', '\U000118c2'), ('\U000118a3', '\U000118c3'), ('\U000118a4', '\U000118c4'),
+ ('\U000118a5', '\U000118c5'), ('\U000118a6', '\U000118c6'), ('\U000118a7', '\U000118c7'),
+ ('\U000118a8', '\U000118c8'), ('\U000118a9', '\U000118c9'), ('\U000118aa', '\U000118ca'),
+ ('\U000118ab', '\U000118cb'), ('\U000118ac', '\U000118cc'), ('\U000118ad', '\U000118cd'),
+ ('\U000118ae', '\U000118ce'), ('\U000118af', '\U000118cf'), ('\U000118b0', '\U000118d0'),
+ ('\U000118b1', '\U000118d1'), ('\U000118b2', '\U000118d2'), ('\U000118b3', '\U000118d3'),
+ ('\U000118b4', '\U000118d4'), ('\U000118b5', '\U000118d5'), ('\U000118b6', '\U000118d6'),
+ ('\U000118b7', '\U000118d7'), ('\U000118b8', '\U000118d8'), ('\U000118b9', '\U000118d9'),
+ ('\U000118ba', '\U000118da'), ('\U000118bb', '\U000118db'), ('\U000118bc', '\U000118dc'),
+ ('\U000118bd', '\U000118dd'), ('\U000118be', '\U000118de'), ('\U000118bf', '\U000118df')
+ ];
+
+ static LlLu_table: &'static [(char, char)] = &[
+ ('\x61', '\x41'), ('\x62', '\x42'), ('\x63', '\x43'), ('\x64', '\x44'), ('\x65', '\x45'),
+ ('\x66', '\x46'), ('\x67', '\x47'), ('\x68', '\x48'), ('\x69', '\x49'), ('\x6a', '\x4a'),
+ ('\x6b', '\x4b'), ('\x6c', '\x4c'), ('\x6d', '\x4d'), ('\x6e', '\x4e'), ('\x6f', '\x4f'),
+ ('\x70', '\x50'), ('\x71', '\x51'), ('\x72', '\x52'), ('\x73', '\x53'), ('\x74', '\x54'),
+ ('\x75', '\x55'), ('\x76', '\x56'), ('\x77', '\x57'), ('\x78', '\x58'), ('\x79', '\x59'),
+ ('\x7a', '\x5a'), ('\xb5', '\u039c'), ('\xe0', '\xc0'), ('\xe1', '\xc1'), ('\xe2', '\xc2'),
+ ('\xe3', '\xc3'), ('\xe4', '\xc4'), ('\xe5', '\xc5'), ('\xe6', '\xc6'), ('\xe7', '\xc7'),
+ ('\xe8', '\xc8'), ('\xe9', '\xc9'), ('\xea', '\xca'), ('\xeb', '\xcb'), ('\xec', '\xcc'),
+ ('\xed', '\xcd'), ('\xee', '\xce'), ('\xef', '\xcf'), ('\xf0', '\xd0'), ('\xf1', '\xd1'),
+ ('\xf2', '\xd2'), ('\xf3', '\xd3'), ('\xf4', '\xd4'), ('\xf5', '\xd5'), ('\xf6', '\xd6'),
+ ('\xf8', '\xd8'), ('\xf9', '\xd9'), ('\xfa', '\xda'), ('\xfb', '\xdb'), ('\xfc', '\xdc'),
+ ('\xfd', '\xdd'), ('\xfe', '\xde'), ('\xff', '\u0178'), ('\u0101', '\u0100'), ('\u0103',
+ '\u0102'), ('\u0105', '\u0104'), ('\u0107', '\u0106'), ('\u0109', '\u0108'), ('\u010b',
+ '\u010a'), ('\u010d', '\u010c'), ('\u010f', '\u010e'), ('\u0111', '\u0110'), ('\u0113',
+ '\u0112'), ('\u0115', '\u0114'), ('\u0117', '\u0116'), ('\u0119', '\u0118'), ('\u011b',
+ '\u011a'), ('\u011d', '\u011c'), ('\u011f', '\u011e'), ('\u0121', '\u0120'), ('\u0123',
+ '\u0122'), ('\u0125', '\u0124'), ('\u0127', '\u0126'), ('\u0129', '\u0128'), ('\u012b',
+ '\u012a'), ('\u012d', '\u012c'), ('\u012f', '\u012e'), ('\u0131', '\x49'), ('\u0133',
+ '\u0132'), ('\u0135', '\u0134'), ('\u0137', '\u0136'), ('\u013a', '\u0139'), ('\u013c',
+ '\u013b'), ('\u013e', '\u013d'), ('\u0140', '\u013f'), ('\u0142', '\u0141'), ('\u0144',
+ '\u0143'), ('\u0146', '\u0145'), ('\u0148', '\u0147'), ('\u014b', '\u014a'), ('\u014d',
+ '\u014c'), ('\u014f', '\u014e'), ('\u0151', '\u0150'), ('\u0153', '\u0152'), ('\u0155',
+ '\u0154'), ('\u0157', '\u0156'), ('\u0159', '\u0158'), ('\u015b', '\u015a'), ('\u015d',
+ '\u015c'), ('\u015f', '\u015e'), ('\u0161', '\u0160'), ('\u0163', '\u0162'), ('\u0165',
+ '\u0164'), ('\u0167', '\u0166'), ('\u0169', '\u0168'), ('\u016b', '\u016a'), ('\u016d',
+ '\u016c'), ('\u016f', '\u016e'), ('\u0171', '\u0170'), ('\u0173', '\u0172'), ('\u0175',
+ '\u0174'), ('\u0177', '\u0176'), ('\u017a', '\u0179'), ('\u017c', '\u017b'), ('\u017e',
+ '\u017d'), ('\u017f', '\x53'), ('\u0180', '\u0243'), ('\u0183', '\u0182'), ('\u0185',
+ '\u0184'), ('\u0188', '\u0187'), ('\u018c', '\u018b'), ('\u0192', '\u0191'), ('\u0195',
+ '\u01f6'), ('\u0199', '\u0198'), ('\u019a', '\u023d'), ('\u019e', '\u0220'), ('\u01a1',
+ '\u01a0'), ('\u01a3', '\u01a2'), ('\u01a5', '\u01a4'), ('\u01a8', '\u01a7'), ('\u01ad',
+ '\u01ac'), ('\u01b0', '\u01af'), ('\u01b4', '\u01b3'), ('\u01b6', '\u01b5'), ('\u01b9',
+ '\u01b8'), ('\u01bd', '\u01bc'), ('\u01bf', '\u01f7'), ('\u01c6', '\u01c4'), ('\u01c9',
+ '\u01c7'), ('\u01cc', '\u01ca'), ('\u01ce', '\u01cd'), ('\u01d0', '\u01cf'), ('\u01d2',
+ '\u01d1'), ('\u01d4', '\u01d3'), ('\u01d6', '\u01d5'), ('\u01d8', '\u01d7'), ('\u01da',
+ '\u01d9'), ('\u01dc', '\u01db'), ('\u01dd', '\u018e'), ('\u01df', '\u01de'), ('\u01e1',
+ '\u01e0'), ('\u01e3', '\u01e2'), ('\u01e5', '\u01e4'), ('\u01e7', '\u01e6'), ('\u01e9',
+ '\u01e8'), ('\u01eb', '\u01ea'), ('\u01ed', '\u01ec'), ('\u01ef', '\u01ee'), ('\u01f3',
+ '\u01f1'), ('\u01f5', '\u01f4'), ('\u01f9', '\u01f8'), ('\u01fb', '\u01fa'), ('\u01fd',
+ '\u01fc'), ('\u01ff', '\u01fe'), ('\u0201', '\u0200'), ('\u0203', '\u0202'), ('\u0205',
+ '\u0204'), ('\u0207', '\u0206'), ('\u0209', '\u0208'), ('\u020b', '\u020a'), ('\u020d',
+ '\u020c'), ('\u020f', '\u020e'), ('\u0211', '\u0210'), ('\u0213', '\u0212'), ('\u0215',
+ '\u0214'), ('\u0217', '\u0216'), ('\u0219', '\u0218'), ('\u021b', '\u021a'), ('\u021d',
+ '\u021c'), ('\u021f', '\u021e'), ('\u0223', '\u0222'), ('\u0225', '\u0224'), ('\u0227',
+ '\u0226'), ('\u0229', '\u0228'), ('\u022b', '\u022a'), ('\u022d', '\u022c'), ('\u022f',
+ '\u022e'), ('\u0231', '\u0230'), ('\u0233', '\u0232'), ('\u023c', '\u023b'), ('\u023f',
+ '\u2c7e'), ('\u0240', '\u2c7f'), ('\u0242', '\u0241'), ('\u0247', '\u0246'), ('\u0249',
+ '\u0248'), ('\u024b', '\u024a'), ('\u024d', '\u024c'), ('\u024f', '\u024e'), ('\u0250',
+ '\u2c6f'), ('\u0251', '\u2c6d'), ('\u0252', '\u2c70'), ('\u0253', '\u0181'), ('\u0254',
+ '\u0186'), ('\u0256', '\u0189'), ('\u0257', '\u018a'), ('\u0259', '\u018f'), ('\u025b',
+ '\u0190'), ('\u025c', '\ua7ab'), ('\u0260', '\u0193'), ('\u0261', '\ua7ac'), ('\u0263',
+ '\u0194'), ('\u0265', '\ua78d'), ('\u0266', '\ua7aa'), ('\u0268', '\u0197'), ('\u0269',
+ '\u0196'), ('\u026b', '\u2c62'), ('\u026c', '\ua7ad'), ('\u026f', '\u019c'), ('\u0271',
+ '\u2c6e'), ('\u0272', '\u019d'), ('\u0275', '\u019f'), ('\u027d', '\u2c64'), ('\u0280',
+ '\u01a6'), ('\u0283', '\u01a9'), ('\u0287', '\ua7b1'), ('\u0288', '\u01ae'), ('\u0289',
+ '\u0244'), ('\u028a', '\u01b1'), ('\u028b', '\u01b2'), ('\u028c', '\u0245'), ('\u0292',
+ '\u01b7'), ('\u029e', '\ua7b0'), ('\u0371', '\u0370'), ('\u0373', '\u0372'), ('\u0377',
+ '\u0376'), ('\u037b', '\u03fd'), ('\u037c', '\u03fe'), ('\u037d', '\u03ff'), ('\u03ac',
+ '\u0386'), ('\u03ad', '\u0388'), ('\u03ae', '\u0389'), ('\u03af', '\u038a'), ('\u03b1',
+ '\u0391'), ('\u03b2', '\u0392'), ('\u03b3', '\u0393'), ('\u03b4', '\u0394'), ('\u03b5',
+ '\u0395'), ('\u03b6', '\u0396'), ('\u03b7', '\u0397'), ('\u03b8', '\u0398'), ('\u03b9',
+ '\u0399'), ('\u03ba', '\u039a'), ('\u03bb', '\u039b'), ('\u03bc', '\u039c'), ('\u03bd',
+ '\u039d'), ('\u03be', '\u039e'), ('\u03bf', '\u039f'), ('\u03c0', '\u03a0'), ('\u03c1',
+ '\u03a1'), ('\u03c2', '\u03a3'), ('\u03c3', '\u03a3'), ('\u03c4', '\u03a4'), ('\u03c5',
+ '\u03a5'), ('\u03c6', '\u03a6'), ('\u03c7', '\u03a7'), ('\u03c8', '\u03a8'), ('\u03c9',
+ '\u03a9'), ('\u03ca', '\u03aa'), ('\u03cb', '\u03ab'), ('\u03cc', '\u038c'), ('\u03cd',
+ '\u038e'), ('\u03ce', '\u038f'), ('\u03d0', '\u0392'), ('\u03d1', '\u0398'), ('\u03d5',
+ '\u03a6'), ('\u03d6', '\u03a0'), ('\u03d7', '\u03cf'), ('\u03d9', '\u03d8'), ('\u03db',
+ '\u03da'), ('\u03dd', '\u03dc'), ('\u03df', '\u03de'), ('\u03e1', '\u03e0'), ('\u03e3',
+ '\u03e2'), ('\u03e5', '\u03e4'), ('\u03e7', '\u03e6'), ('\u03e9', '\u03e8'), ('\u03eb',
+ '\u03ea'), ('\u03ed', '\u03ec'), ('\u03ef', '\u03ee'), ('\u03f0', '\u039a'), ('\u03f1',
+ '\u03a1'), ('\u03f2', '\u03f9'), ('\u03f3', '\u037f'), ('\u03f5', '\u0395'), ('\u03f8',
+ '\u03f7'), ('\u03fb', '\u03fa'), ('\u0430', '\u0410'), ('\u0431', '\u0411'), ('\u0432',
+ '\u0412'), ('\u0433', '\u0413'), ('\u0434', '\u0414'), ('\u0435', '\u0415'), ('\u0436',
+ '\u0416'), ('\u0437', '\u0417'), ('\u0438', '\u0418'), ('\u0439', '\u0419'), ('\u043a',
+ '\u041a'), ('\u043b', '\u041b'), ('\u043c', '\u041c'), ('\u043d', '\u041d'), ('\u043e',
+ '\u041e'), ('\u043f', '\u041f'), ('\u0440', '\u0420'), ('\u0441', '\u0421'), ('\u0442',
+ '\u0422'), ('\u0443', '\u0423'), ('\u0444', '\u0424'), ('\u0445', '\u0425'), ('\u0446',
+ '\u0426'), ('\u0447', '\u0427'), ('\u0448', '\u0428'), ('\u0449', '\u0429'), ('\u044a',
+ '\u042a'), ('\u044b', '\u042b'), ('\u044c', '\u042c'), ('\u044d', '\u042d'), ('\u044e',
+ '\u042e'), ('\u044f', '\u042f'), ('\u0450', '\u0400'), ('\u0451', '\u0401'), ('\u0452',
+ '\u0402'), ('\u0453', '\u0403'), ('\u0454', '\u0404'), ('\u0455', '\u0405'), ('\u0456',
+ '\u0406'), ('\u0457', '\u0407'), ('\u0458', '\u0408'), ('\u0459', '\u0409'), ('\u045a',
+ '\u040a'), ('\u045b', '\u040b'), ('\u045c', '\u040c'), ('\u045d', '\u040d'), ('\u045e',
+ '\u040e'), ('\u045f', '\u040f'), ('\u0461', '\u0460'), ('\u0463', '\u0462'), ('\u0465',
+ '\u0464'), ('\u0467', '\u0466'), ('\u0469', '\u0468'), ('\u046b', '\u046a'), ('\u046d',
+ '\u046c'), ('\u046f', '\u046e'), ('\u0471', '\u0470'), ('\u0473', '\u0472'), ('\u0475',
+ '\u0474'), ('\u0477', '\u0476'), ('\u0479', '\u0478'), ('\u047b', '\u047a'), ('\u047d',
+ '\u047c'), ('\u047f', '\u047e'), ('\u0481', '\u0480'), ('\u048b', '\u048a'), ('\u048d',
+ '\u048c'), ('\u048f', '\u048e'), ('\u0491', '\u0490'), ('\u0493', '\u0492'), ('\u0495',
+ '\u0494'), ('\u0497', '\u0496'), ('\u0499', '\u0498'), ('\u049b', '\u049a'), ('\u049d',
+ '\u049c'), ('\u049f', '\u049e'), ('\u04a1', '\u04a0'), ('\u04a3', '\u04a2'), ('\u04a5',
+ '\u04a4'), ('\u04a7', '\u04a6'), ('\u04a9', '\u04a8'), ('\u04ab', '\u04aa'), ('\u04ad',
+ '\u04ac'), ('\u04af', '\u04ae'), ('\u04b1', '\u04b0'), ('\u04b3', '\u04b2'), ('\u04b5',
+ '\u04b4'), ('\u04b7', '\u04b6'), ('\u04b9', '\u04b8'), ('\u04bb', '\u04ba'), ('\u04bd',
+ '\u04bc'), ('\u04bf', '\u04be'), ('\u04c2', '\u04c1'), ('\u04c4', '\u04c3'), ('\u04c6',
+ '\u04c5'), ('\u04c8', '\u04c7'), ('\u04ca', '\u04c9'), ('\u04cc', '\u04cb'), ('\u04ce',
+ '\u04cd'), ('\u04cf', '\u04c0'), ('\u04d1', '\u04d0'), ('\u04d3', '\u04d2'), ('\u04d5',
+ '\u04d4'), ('\u04d7', '\u04d6'), ('\u04d9', '\u04d8'), ('\u04db', '\u04da'), ('\u04dd',
+ '\u04dc'), ('\u04df', '\u04de'), ('\u04e1', '\u04e0'), ('\u04e3', '\u04e2'), ('\u04e5',
+ '\u04e4'), ('\u04e7', '\u04e6'), ('\u04e9', '\u04e8'), ('\u04eb', '\u04ea'), ('\u04ed',
+ '\u04ec'), ('\u04ef', '\u04ee'), ('\u04f1', '\u04f0'), ('\u04f3', '\u04f2'), ('\u04f5',
+ '\u04f4'), ('\u04f7', '\u04f6'), ('\u04f9', '\u04f8'), ('\u04fb', '\u04fa'), ('\u04fd',
+ '\u04fc'), ('\u04ff', '\u04fe'), ('\u0501', '\u0500'), ('\u0503', '\u0502'), ('\u0505',
+ '\u0504'), ('\u0507', '\u0506'), ('\u0509', '\u0508'), ('\u050b', '\u050a'), ('\u050d',
+ '\u050c'), ('\u050f', '\u050e'), ('\u0511', '\u0510'), ('\u0513', '\u0512'), ('\u0515',
+ '\u0514'), ('\u0517', '\u0516'), ('\u0519', '\u0518'), ('\u051b', '\u051a'), ('\u051d',
+ '\u051c'), ('\u051f', '\u051e'), ('\u0521', '\u0520'), ('\u0523', '\u0522'), ('\u0525',
+ '\u0524'), ('\u0527', '\u0526'), ('\u0529', '\u0528'), ('\u052b', '\u052a'), ('\u052d',
+ '\u052c'), ('\u052f', '\u052e'), ('\u0561', '\u0531'), ('\u0562', '\u0532'), ('\u0563',
+ '\u0533'), ('\u0564', '\u0534'), ('\u0565', '\u0535'), ('\u0566', '\u0536'), ('\u0567',
+ '\u0537'), ('\u0568', '\u0538'), ('\u0569', '\u0539'), ('\u056a', '\u053a'), ('\u056b',
+ '\u053b'), ('\u056c', '\u053c'), ('\u056d', '\u053d'), ('\u056e', '\u053e'), ('\u056f',
+ '\u053f'), ('\u0570', '\u0540'), ('\u0571', '\u0541'), ('\u0572', '\u0542'), ('\u0573',
+ '\u0543'), ('\u0574', '\u0544'), ('\u0575', '\u0545'), ('\u0576', '\u0546'), ('\u0577',
+ '\u0547'), ('\u0578', '\u0548'), ('\u0579', '\u0549'), ('\u057a', '\u054a'), ('\u057b',
+ '\u054b'), ('\u057c', '\u054c'), ('\u057d', '\u054d'), ('\u057e', '\u054e'), ('\u057f',
+ '\u054f'), ('\u0580', '\u0550'), ('\u0581', '\u0551'), ('\u0582', '\u0552'), ('\u0583',
+ '\u0553'), ('\u0584', '\u0554'), ('\u0585', '\u0555'), ('\u0586', '\u0556'), ('\u1d79',
+ '\ua77d'), ('\u1d7d', '\u2c63'), ('\u1e01', '\u1e00'), ('\u1e03', '\u1e02'), ('\u1e05',
+ '\u1e04'), ('\u1e07', '\u1e06'), ('\u1e09', '\u1e08'), ('\u1e0b', '\u1e0a'), ('\u1e0d',
+ '\u1e0c'), ('\u1e0f', '\u1e0e'), ('\u1e11', '\u1e10'), ('\u1e13', '\u1e12'), ('\u1e15',
+ '\u1e14'), ('\u1e17', '\u1e16'), ('\u1e19', '\u1e18'), ('\u1e1b', '\u1e1a'), ('\u1e1d',
+ '\u1e1c'), ('\u1e1f', '\u1e1e'), ('\u1e21', '\u1e20'), ('\u1e23', '\u1e22'), ('\u1e25',
+ '\u1e24'), ('\u1e27', '\u1e26'), ('\u1e29', '\u1e28'), ('\u1e2b', '\u1e2a'), ('\u1e2d',
+ '\u1e2c'), ('\u1e2f', '\u1e2e'), ('\u1e31', '\u1e30'), ('\u1e33', '\u1e32'), ('\u1e35',
+ '\u1e34'), ('\u1e37', '\u1e36'), ('\u1e39', '\u1e38'), ('\u1e3b', '\u1e3a'), ('\u1e3d',
+ '\u1e3c'), ('\u1e3f', '\u1e3e'), ('\u1e41', '\u1e40'), ('\u1e43', '\u1e42'), ('\u1e45',
+ '\u1e44'), ('\u1e47', '\u1e46'), ('\u1e49', '\u1e48'), ('\u1e4b', '\u1e4a'), ('\u1e4d',
+ '\u1e4c'), ('\u1e4f', '\u1e4e'), ('\u1e51', '\u1e50'), ('\u1e53', '\u1e52'), ('\u1e55',
+ '\u1e54'), ('\u1e57', '\u1e56'), ('\u1e59', '\u1e58'), ('\u1e5b', '\u1e5a'), ('\u1e5d',
+ '\u1e5c'), ('\u1e5f', '\u1e5e'), ('\u1e61', '\u1e60'), ('\u1e63', '\u1e62'), ('\u1e65',
+ '\u1e64'), ('\u1e67', '\u1e66'), ('\u1e69', '\u1e68'), ('\u1e6b', '\u1e6a'), ('\u1e6d',
+ '\u1e6c'), ('\u1e6f', '\u1e6e'), ('\u1e71', '\u1e70'), ('\u1e73', '\u1e72'), ('\u1e75',
+ '\u1e74'), ('\u1e77', '\u1e76'), ('\u1e79', '\u1e78'), ('\u1e7b', '\u1e7a'), ('\u1e7d',
+ '\u1e7c'), ('\u1e7f', '\u1e7e'), ('\u1e81', '\u1e80'), ('\u1e83', '\u1e82'), ('\u1e85',
+ '\u1e84'), ('\u1e87', '\u1e86'), ('\u1e89', '\u1e88'), ('\u1e8b', '\u1e8a'), ('\u1e8d',
+ '\u1e8c'), ('\u1e8f', '\u1e8e'), ('\u1e91', '\u1e90'), ('\u1e93', '\u1e92'), ('\u1e95',
+ '\u1e94'), ('\u1e9b', '\u1e60'), ('\u1ea1', '\u1ea0'), ('\u1ea3', '\u1ea2'), ('\u1ea5',
+ '\u1ea4'), ('\u1ea7', '\u1ea6'), ('\u1ea9', '\u1ea8'), ('\u1eab', '\u1eaa'), ('\u1ead',
+ '\u1eac'), ('\u1eaf', '\u1eae'), ('\u1eb1', '\u1eb0'), ('\u1eb3', '\u1eb2'), ('\u1eb5',
+ '\u1eb4'), ('\u1eb7', '\u1eb6'), ('\u1eb9', '\u1eb8'), ('\u1ebb', '\u1eba'), ('\u1ebd',
+ '\u1ebc'), ('\u1ebf', '\u1ebe'), ('\u1ec1', '\u1ec0'), ('\u1ec3', '\u1ec2'), ('\u1ec5',
+ '\u1ec4'), ('\u1ec7', '\u1ec6'), ('\u1ec9', '\u1ec8'), ('\u1ecb', '\u1eca'), ('\u1ecd',
+ '\u1ecc'), ('\u1ecf', '\u1ece'), ('\u1ed1', '\u1ed0'), ('\u1ed3', '\u1ed2'), ('\u1ed5',
+ '\u1ed4'), ('\u1ed7', '\u1ed6'), ('\u1ed9', '\u1ed8'), ('\u1edb', '\u1eda'), ('\u1edd',
+ '\u1edc'), ('\u1edf', '\u1ede'), ('\u1ee1', '\u1ee0'), ('\u1ee3', '\u1ee2'), ('\u1ee5',
+ '\u1ee4'), ('\u1ee7', '\u1ee6'), ('\u1ee9', '\u1ee8'), ('\u1eeb', '\u1eea'), ('\u1eed',
+ '\u1eec'), ('\u1eef', '\u1eee'), ('\u1ef1', '\u1ef0'), ('\u1ef3', '\u1ef2'), ('\u1ef5',
+ '\u1ef4'), ('\u1ef7', '\u1ef6'), ('\u1ef9', '\u1ef8'), ('\u1efb', '\u1efa'), ('\u1efd',
+ '\u1efc'), ('\u1eff', '\u1efe'), ('\u1f00', '\u1f08'), ('\u1f01', '\u1f09'), ('\u1f02',
+ '\u1f0a'), ('\u1f03', '\u1f0b'), ('\u1f04', '\u1f0c'), ('\u1f05', '\u1f0d'), ('\u1f06',
+ '\u1f0e'), ('\u1f07', '\u1f0f'), ('\u1f10', '\u1f18'), ('\u1f11', '\u1f19'), ('\u1f12',
+ '\u1f1a'), ('\u1f13', '\u1f1b'), ('\u1f14', '\u1f1c'), ('\u1f15', '\u1f1d'), ('\u1f20',
+ '\u1f28'), ('\u1f21', '\u1f29'), ('\u1f22', '\u1f2a'), ('\u1f23', '\u1f2b'), ('\u1f24',
+ '\u1f2c'), ('\u1f25', '\u1f2d'), ('\u1f26', '\u1f2e'), ('\u1f27', '\u1f2f'), ('\u1f30',
+ '\u1f38'), ('\u1f31', '\u1f39'), ('\u1f32', '\u1f3a'), ('\u1f33', '\u1f3b'), ('\u1f34',
+ '\u1f3c'), ('\u1f35', '\u1f3d'), ('\u1f36', '\u1f3e'), ('\u1f37', '\u1f3f'), ('\u1f40',
+ '\u1f48'), ('\u1f41', '\u1f49'), ('\u1f42', '\u1f4a'), ('\u1f43', '\u1f4b'), ('\u1f44',
+ '\u1f4c'), ('\u1f45', '\u1f4d'), ('\u1f51', '\u1f59'), ('\u1f53', '\u1f5b'), ('\u1f55',
+ '\u1f5d'), ('\u1f57', '\u1f5f'), ('\u1f60', '\u1f68'), ('\u1f61', '\u1f69'), ('\u1f62',
+ '\u1f6a'), ('\u1f63', '\u1f6b'), ('\u1f64', '\u1f6c'), ('\u1f65', '\u1f6d'), ('\u1f66',
+ '\u1f6e'), ('\u1f67', '\u1f6f'), ('\u1f70', '\u1fba'), ('\u1f71', '\u1fbb'), ('\u1f72',
+ '\u1fc8'), ('\u1f73', '\u1fc9'), ('\u1f74', '\u1fca'), ('\u1f75', '\u1fcb'), ('\u1f76',
+ '\u1fda'), ('\u1f77', '\u1fdb'), ('\u1f78', '\u1ff8'), ('\u1f79', '\u1ff9'), ('\u1f7a',
+ '\u1fea'), ('\u1f7b', '\u1feb'), ('\u1f7c', '\u1ffa'), ('\u1f7d', '\u1ffb'), ('\u1f80',
+ '\u1f88'), ('\u1f81', '\u1f89'), ('\u1f82', '\u1f8a'), ('\u1f83', '\u1f8b'), ('\u1f84',
+ '\u1f8c'), ('\u1f85', '\u1f8d'), ('\u1f86', '\u1f8e'), ('\u1f87', '\u1f8f'), ('\u1f90',
+ '\u1f98'), ('\u1f91', '\u1f99'), ('\u1f92', '\u1f9a'), ('\u1f93', '\u1f9b'), ('\u1f94',
+ '\u1f9c'), ('\u1f95', '\u1f9d'), ('\u1f96', '\u1f9e'), ('\u1f97', '\u1f9f'), ('\u1fa0',
+ '\u1fa8'), ('\u1fa1', '\u1fa9'), ('\u1fa2', '\u1faa'), ('\u1fa3', '\u1fab'), ('\u1fa4',
+ '\u1fac'), ('\u1fa5', '\u1fad'), ('\u1fa6', '\u1fae'), ('\u1fa7', '\u1faf'), ('\u1fb0',
+ '\u1fb8'), ('\u1fb1', '\u1fb9'), ('\u1fb3', '\u1fbc'), ('\u1fbe', '\u0399'), ('\u1fc3',
+ '\u1fcc'), ('\u1fd0', '\u1fd8'), ('\u1fd1', '\u1fd9'), ('\u1fe0', '\u1fe8'), ('\u1fe1',
+ '\u1fe9'), ('\u1fe5', '\u1fec'), ('\u1ff3', '\u1ffc'), ('\u214e', '\u2132'), ('\u2184',
+ '\u2183'), ('\u2c30', '\u2c00'), ('\u2c31', '\u2c01'), ('\u2c32', '\u2c02'), ('\u2c33',
+ '\u2c03'), ('\u2c34', '\u2c04'), ('\u2c35', '\u2c05'), ('\u2c36', '\u2c06'), ('\u2c37',
+ '\u2c07'), ('\u2c38', '\u2c08'), ('\u2c39', '\u2c09'), ('\u2c3a', '\u2c0a'), ('\u2c3b',
+ '\u2c0b'), ('\u2c3c', '\u2c0c'), ('\u2c3d', '\u2c0d'), ('\u2c3e', '\u2c0e'), ('\u2c3f',
+ '\u2c0f'), ('\u2c40', '\u2c10'), ('\u2c41', '\u2c11'), ('\u2c42', '\u2c12'), ('\u2c43',
+ '\u2c13'), ('\u2c44', '\u2c14'), ('\u2c45', '\u2c15'), ('\u2c46', '\u2c16'), ('\u2c47',
+ '\u2c17'), ('\u2c48', '\u2c18'), ('\u2c49', '\u2c19'), ('\u2c4a', '\u2c1a'), ('\u2c4b',
+ '\u2c1b'), ('\u2c4c', '\u2c1c'), ('\u2c4d', '\u2c1d'), ('\u2c4e', '\u2c1e'), ('\u2c4f',
+ '\u2c1f'), ('\u2c50', '\u2c20'), ('\u2c51', '\u2c21'), ('\u2c52', '\u2c22'), ('\u2c53',
+ '\u2c23'), ('\u2c54', '\u2c24'), ('\u2c55', '\u2c25'), ('\u2c56', '\u2c26'), ('\u2c57',
+ '\u2c27'), ('\u2c58', '\u2c28'), ('\u2c59', '\u2c29'), ('\u2c5a', '\u2c2a'), ('\u2c5b',
+ '\u2c2b'), ('\u2c5c', '\u2c2c'), ('\u2c5d', '\u2c2d'), ('\u2c5e', '\u2c2e'), ('\u2c61',
+ '\u2c60'), ('\u2c65', '\u023a'), ('\u2c66', '\u023e'), ('\u2c68', '\u2c67'), ('\u2c6a',
+ '\u2c69'), ('\u2c6c', '\u2c6b'), ('\u2c73', '\u2c72'), ('\u2c76', '\u2c75'), ('\u2c81',
+ '\u2c80'), ('\u2c83', '\u2c82'), ('\u2c85', '\u2c84'), ('\u2c87', '\u2c86'), ('\u2c89',
+ '\u2c88'), ('\u2c8b', '\u2c8a'), ('\u2c8d', '\u2c8c'), ('\u2c8f', '\u2c8e'), ('\u2c91',
+ '\u2c90'), ('\u2c93', '\u2c92'), ('\u2c95', '\u2c94'), ('\u2c97', '\u2c96'), ('\u2c99',
+ '\u2c98'), ('\u2c9b', '\u2c9a'), ('\u2c9d', '\u2c9c'), ('\u2c9f', '\u2c9e'), ('\u2ca1',
+ '\u2ca0'), ('\u2ca3', '\u2ca2'), ('\u2ca5', '\u2ca4'), ('\u2ca7', '\u2ca6'), ('\u2ca9',
+ '\u2ca8'), ('\u2cab', '\u2caa'), ('\u2cad', '\u2cac'), ('\u2caf', '\u2cae'), ('\u2cb1',
+ '\u2cb0'), ('\u2cb3', '\u2cb2'), ('\u2cb5', '\u2cb4'), ('\u2cb7', '\u2cb6'), ('\u2cb9',
+ '\u2cb8'), ('\u2cbb', '\u2cba'), ('\u2cbd', '\u2cbc'), ('\u2cbf', '\u2cbe'), ('\u2cc1',
+ '\u2cc0'), ('\u2cc3', '\u2cc2'), ('\u2cc5', '\u2cc4'), ('\u2cc7', '\u2cc6'), ('\u2cc9',
+ '\u2cc8'), ('\u2ccb', '\u2cca'), ('\u2ccd', '\u2ccc'), ('\u2ccf', '\u2cce'), ('\u2cd1',
+ '\u2cd0'), ('\u2cd3', '\u2cd2'), ('\u2cd5', '\u2cd4'), ('\u2cd7', '\u2cd6'), ('\u2cd9',
+ '\u2cd8'), ('\u2cdb', '\u2cda'), ('\u2cdd', '\u2cdc'), ('\u2cdf', '\u2cde'), ('\u2ce1',
+ '\u2ce0'), ('\u2ce3', '\u2ce2'), ('\u2cec', '\u2ceb'), ('\u2cee', '\u2ced'), ('\u2cf3',
+ '\u2cf2'), ('\u2d00', '\u10a0'), ('\u2d01', '\u10a1'), ('\u2d02', '\u10a2'), ('\u2d03',
+ '\u10a3'), ('\u2d04', '\u10a4'), ('\u2d05', '\u10a5'), ('\u2d06', '\u10a6'), ('\u2d07',
+ '\u10a7'), ('\u2d08', '\u10a8'), ('\u2d09', '\u10a9'), ('\u2d0a', '\u10aa'), ('\u2d0b',
+ '\u10ab'), ('\u2d0c', '\u10ac'), ('\u2d0d', '\u10ad'), ('\u2d0e', '\u10ae'), ('\u2d0f',
+ '\u10af'), ('\u2d10', '\u10b0'), ('\u2d11', '\u10b1'), ('\u2d12', '\u10b2'), ('\u2d13',
+ '\u10b3'), ('\u2d14', '\u10b4'), ('\u2d15', '\u10b5'), ('\u2d16', '\u10b6'), ('\u2d17',
+ '\u10b7'), ('\u2d18', '\u10b8'), ('\u2d19', '\u10b9'), ('\u2d1a', '\u10ba'), ('\u2d1b',
+ '\u10bb'), ('\u2d1c', '\u10bc'), ('\u2d1d', '\u10bd'), ('\u2d1e', '\u10be'), ('\u2d1f',
+ '\u10bf'), ('\u2d20', '\u10c0'), ('\u2d21', '\u10c1'), ('\u2d22', '\u10c2'), ('\u2d23',
+ '\u10c3'), ('\u2d24', '\u10c4'), ('\u2d25', '\u10c5'), ('\u2d27', '\u10c7'), ('\u2d2d',
+ '\u10cd'), ('\ua641', '\ua640'), ('\ua643', '\ua642'), ('\ua645', '\ua644'), ('\ua647',
+ '\ua646'), ('\ua649', '\ua648'), ('\ua64b', '\ua64a'), ('\ua64d', '\ua64c'), ('\ua64f',
+ '\ua64e'), ('\ua651', '\ua650'), ('\ua653', '\ua652'), ('\ua655', '\ua654'), ('\ua657',
+ '\ua656'), ('\ua659', '\ua658'), ('\ua65b', '\ua65a'), ('\ua65d', '\ua65c'), ('\ua65f',
+ '\ua65e'), ('\ua661', '\ua660'), ('\ua663', '\ua662'), ('\ua665', '\ua664'), ('\ua667',
+ '\ua666'), ('\ua669', '\ua668'), ('\ua66b', '\ua66a'), ('\ua66d', '\ua66c'), ('\ua681',
+ '\ua680'), ('\ua683', '\ua682'), ('\ua685', '\ua684'), ('\ua687', '\ua686'), ('\ua689',
+ '\ua688'), ('\ua68b', '\ua68a'), ('\ua68d', '\ua68c'), ('\ua68f', '\ua68e'), ('\ua691',
+ '\ua690'), ('\ua693', '\ua692'), ('\ua695', '\ua694'), ('\ua697', '\ua696'), ('\ua699',
+ '\ua698'), ('\ua69b', '\ua69a'), ('\ua723', '\ua722'), ('\ua725', '\ua724'), ('\ua727',
+ '\ua726'), ('\ua729', '\ua728'), ('\ua72b', '\ua72a'), ('\ua72d', '\ua72c'), ('\ua72f',
+ '\ua72e'), ('\ua733', '\ua732'), ('\ua735', '\ua734'), ('\ua737', '\ua736'), ('\ua739',
+ '\ua738'), ('\ua73b', '\ua73a'), ('\ua73d', '\ua73c'), ('\ua73f', '\ua73e'), ('\ua741',
+ '\ua740'), ('\ua743', '\ua742'), ('\ua745', '\ua744'), ('\ua747', '\ua746'), ('\ua749',
+ '\ua748'), ('\ua74b', '\ua74a'), ('\ua74d', '\ua74c'), ('\ua74f', '\ua74e'), ('\ua751',
+ '\ua750'), ('\ua753', '\ua752'), ('\ua755', '\ua754'), ('\ua757', '\ua756'), ('\ua759',
+ '\ua758'), ('\ua75b', '\ua75a'), ('\ua75d', '\ua75c'), ('\ua75f', '\ua75e'), ('\ua761',
+ '\ua760'), ('\ua763', '\ua762'), ('\ua765', '\ua764'), ('\ua767', '\ua766'), ('\ua769',
+ '\ua768'), ('\ua76b', '\ua76a'), ('\ua76d', '\ua76c'), ('\ua76f', '\ua76e'), ('\ua77a',
+ '\ua779'), ('\ua77c', '\ua77b'), ('\ua77f', '\ua77e'), ('\ua781', '\ua780'), ('\ua783',
+ '\ua782'), ('\ua785', '\ua784'), ('\ua787', '\ua786'), ('\ua78c', '\ua78b'), ('\ua791',
+ '\ua790'), ('\ua793', '\ua792'), ('\ua797', '\ua796'), ('\ua799', '\ua798'), ('\ua79b',
+ '\ua79a'), ('\ua79d', '\ua79c'), ('\ua79f', '\ua79e'), ('\ua7a1', '\ua7a0'), ('\ua7a3',
+ '\ua7a2'), ('\ua7a5', '\ua7a4'), ('\ua7a7', '\ua7a6'), ('\ua7a9', '\ua7a8'), ('\uff41',
+ '\uff21'), ('\uff42', '\uff22'), ('\uff43', '\uff23'), ('\uff44', '\uff24'), ('\uff45',
+ '\uff25'), ('\uff46', '\uff26'), ('\uff47', '\uff27'), ('\uff48', '\uff28'), ('\uff49',
+ '\uff29'), ('\uff4a', '\uff2a'), ('\uff4b', '\uff2b'), ('\uff4c', '\uff2c'), ('\uff4d',
+ '\uff2d'), ('\uff4e', '\uff2e'), ('\uff4f', '\uff2f'), ('\uff50', '\uff30'), ('\uff51',
+ '\uff31'), ('\uff52', '\uff32'), ('\uff53', '\uff33'), ('\uff54', '\uff34'), ('\uff55',
+ '\uff35'), ('\uff56', '\uff36'), ('\uff57', '\uff37'), ('\uff58', '\uff38'), ('\uff59',
+ '\uff39'), ('\uff5a', '\uff3a'), ('\U00010428', '\U00010400'), ('\U00010429', '\U00010401'),
+ ('\U0001042a', '\U00010402'), ('\U0001042b', '\U00010403'), ('\U0001042c', '\U00010404'),
+ ('\U0001042d', '\U00010405'), ('\U0001042e', '\U00010406'), ('\U0001042f', '\U00010407'),
+ ('\U00010430', '\U00010408'), ('\U00010431', '\U00010409'), ('\U00010432', '\U0001040a'),
+ ('\U00010433', '\U0001040b'), ('\U00010434', '\U0001040c'), ('\U00010435', '\U0001040d'),
+ ('\U00010436', '\U0001040e'), ('\U00010437', '\U0001040f'), ('\U00010438', '\U00010410'),
+ ('\U00010439', '\U00010411'), ('\U0001043a', '\U00010412'), ('\U0001043b', '\U00010413'),
+ ('\U0001043c', '\U00010414'), ('\U0001043d', '\U00010415'), ('\U0001043e', '\U00010416'),
+ ('\U0001043f', '\U00010417'), ('\U00010440', '\U00010418'), ('\U00010441', '\U00010419'),
+ ('\U00010442', '\U0001041a'), ('\U00010443', '\U0001041b'), ('\U00010444', '\U0001041c'),
+ ('\U00010445', '\U0001041d'), ('\U00010446', '\U0001041e'), ('\U00010447', '\U0001041f'),
+ ('\U00010448', '\U00010420'), ('\U00010449', '\U00010421'), ('\U0001044a', '\U00010422'),
+ ('\U0001044b', '\U00010423'), ('\U0001044c', '\U00010424'), ('\U0001044d', '\U00010425'),
+ ('\U0001044e', '\U00010426'), ('\U0001044f', '\U00010427'), ('\U000118c0', '\U000118a0'),
+ ('\U000118c1', '\U000118a1'), ('\U000118c2', '\U000118a2'), ('\U000118c3', '\U000118a3'),
+ ('\U000118c4', '\U000118a4'), ('\U000118c5', '\U000118a5'), ('\U000118c6', '\U000118a6'),
+ ('\U000118c7', '\U000118a7'), ('\U000118c8', '\U000118a8'), ('\U000118c9', '\U000118a9'),
+ ('\U000118ca', '\U000118aa'), ('\U000118cb', '\U000118ab'), ('\U000118cc', '\U000118ac'),
+ ('\U000118cd', '\U000118ad'), ('\U000118ce', '\U000118ae'), ('\U000118cf', '\U000118af'),
+ ('\U000118d0', '\U000118b0'), ('\U000118d1', '\U000118b1'), ('\U000118d2', '\U000118b2'),
+ ('\U000118d3', '\U000118b3'), ('\U000118d4', '\U000118b4'), ('\U000118d5', '\U000118b5'),
+ ('\U000118d6', '\U000118b6'), ('\U000118d7', '\U000118b7'), ('\U000118d8', '\U000118b8'),
+ ('\U000118d9', '\U000118b9'), ('\U000118da', '\U000118ba'), ('\U000118db', '\U000118bb'),
+ ('\U000118dc', '\U000118bc'), ('\U000118dd', '\U000118bd'), ('\U000118de', '\U000118be'),
+ ('\U000118df', '\U000118bf')
+ ];
+
+}
+
+pub mod charwidth {
+ use core::option::{Option, Some, None};
+ use core::slice::ImmutableVector;
+
+ fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
+ use core::cmp::{Equal, Less, Greater};
+ match r.bsearch(|&(lo, hi, _, _)| {
+ if lo <= c && c <= hi { Equal }
+ else if hi < c { Less }
+ else { Greater }
+ }) {
+ Some(idx) => {
+ let (_, _, r_ncjk, r_cjk) = r[idx];
+ if is_cjk { r_cjk } else { r_ncjk }
+ }
+ None => 1
+ }
+ }
+
+ pub fn width(c: char, is_cjk: bool) -> Option<uint> {
+ match c as uint {
+ _c @ 0 => Some(0), // null is zero width
+ cu if cu < 0x20 => None, // control sequences have no width
+ cu if cu < 0x7F => Some(1), // ASCII
+ cu if cu < 0xA0 => None, // more control sequences
+ _ => Some(bsearch_range_value_table(c, is_cjk, charwidth_table) as uint)
+ }
+ }
+
+ // character width table. Based on Markus Kuhn's free wcwidth() implementation,
+ // http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+ static charwidth_table: &'static [(char, char, u8, u8)] = &[
+ ('\xa1', '\xa1', 1, 2), ('\xa4', '\xa4', 1, 2), ('\xa7', '\xa8', 1, 2), ('\xaa', '\xaa', 1,
+ 2), ('\xae', '\xae', 1, 2), ('\xb0', '\xb4', 1, 2), ('\xb6', '\xba', 1, 2), ('\xbc', '\xbf',
+ 1, 2), ('\xc6', '\xc6', 1, 2), ('\xd0', '\xd0', 1, 2), ('\xd7', '\xd8', 1, 2), ('\xde',
+ '\xe1', 1, 2), ('\xe6', '\xe6', 1, 2), ('\xe8', '\xea', 1, 2), ('\xec', '\xed', 1, 2),
+ ('\xf0', '\xf0', 1, 2), ('\xf2', '\xf3', 1, 2), ('\xf7', '\xfa', 1, 2), ('\xfc', '\xfc', 1,
+ 2), ('\xfe', '\xfe', 1, 2), ('\u0101', '\u0101', 1, 2), ('\u0111', '\u0111', 1, 2),
+ ('\u0113', '\u0113', 1, 2), ('\u011b', '\u011b', 1, 2), ('\u0126', '\u0127', 1, 2),
+ ('\u012b', '\u012b', 1, 2), ('\u0131', '\u0133', 1, 2), ('\u0138', '\u0138', 1, 2),
+ ('\u013f', '\u0142', 1, 2), ('\u0144', '\u0144', 1, 2), ('\u0148', '\u014b', 1, 2),
+ ('\u014d', '\u014d', 1, 2), ('\u0152', '\u0153', 1, 2), ('\u0166', '\u0167', 1, 2),
+ ('\u016b', '\u016b', 1, 2), ('\u01ce', '\u01ce', 1, 2), ('\u01d0', '\u01d0', 1, 2),
+ ('\u01d2', '\u01d2', 1, 2), ('\u01d4', '\u01d4', 1, 2), ('\u01d6', '\u01d6', 1, 2),
+ ('\u01d8', '\u01d8', 1, 2), ('\u01da', '\u01da', 1, 2), ('\u01dc', '\u01dc', 1, 2),
+ ('\u0251', '\u0251', 1, 2), ('\u0261', '\u0261', 1, 2), ('\u02c4', '\u02c4', 1, 2),
+ ('\u02c7', '\u02c7', 1, 2), ('\u02c9', '\u02cb', 1, 2), ('\u02cd', '\u02cd', 1, 2),
+ ('\u02d0', '\u02d0', 1, 2), ('\u02d8', '\u02db', 1, 2), ('\u02dd', '\u02dd', 1, 2),
+ ('\u02df', '\u02df', 1, 2), ('\u0300', '\u036f', 0, 0), ('\u0391', '\u03a1', 1, 2),
+ ('\u03a3', '\u03a9', 1, 2), ('\u03b1', '\u03c1', 1, 2), ('\u03c3', '\u03c9', 1, 2),
+ ('\u0401', '\u0401', 1, 2), ('\u0410', '\u044f', 1, 2), ('\u0451', '\u0451', 1, 2),
+ ('\u0483', '\u0489', 0, 0), ('\u0591', '\u05bd', 0, 0), ('\u05bf', '\u05bf', 0, 0),
+ ('\u05c1', '\u05c2', 0, 0), ('\u05c4', '\u05c5', 0, 0), ('\u05c7', '\u05c7', 0, 0),
+ ('\u0600', '\u0605', 0, 0), ('\u0610', '\u061a', 0, 0), ('\u061c', '\u061c', 0, 0),
+ ('\u064b', '\u065f', 0, 0), ('\u0670', '\u0670', 0, 0), ('\u06d6', '\u06dd', 0, 0),
+ ('\u06df', '\u06e4', 0, 0), ('\u06e7', '\u06e8', 0, 0), ('\u06ea', '\u06ed', 0, 0),
+ ('\u070f', '\u070f', 0, 0), ('\u0711', '\u0711', 0, 0), ('\u0730', '\u074a', 0, 0),
+ ('\u07a6', '\u07b0', 0, 0), ('\u07eb', '\u07f3', 0, 0), ('\u0816', '\u0819', 0, 0),
+ ('\u081b', '\u0823', 0, 0), ('\u0825', '\u0827', 0, 0), ('\u0829', '\u082d', 0, 0),
+ ('\u0859', '\u085b', 0, 0), ('\u08e4', '\u0902', 0, 0), ('\u093a', '\u093a', 0, 0),
+ ('\u093c', '\u093c', 0, 0), ('\u0941', '\u0948', 0, 0), ('\u094d', '\u094d', 0, 0),
+ ('\u0951', '\u0957', 0, 0), ('\u0962', '\u0963', 0, 0), ('\u0981', '\u0981', 0, 0),
+ ('\u09bc', '\u09bc', 0, 0), ('\u09c1', '\u09c4', 0, 0), ('\u09cd', '\u09cd', 0, 0),
+ ('\u09e2', '\u09e3', 0, 0), ('\u0a01', '\u0a02', 0, 0), ('\u0a3c', '\u0a3c', 0, 0),
+ ('\u0a41', '\u0a42', 0, 0), ('\u0a47', '\u0a48', 0, 0), ('\u0a4b', '\u0a4d', 0, 0),
+ ('\u0a51', '\u0a51', 0, 0), ('\u0a70', '\u0a71', 0, 0), ('\u0a75', '\u0a75', 0, 0),
+ ('\u0a81', '\u0a82', 0, 0), ('\u0abc', '\u0abc', 0, 0), ('\u0ac1', '\u0ac5', 0, 0),
+ ('\u0ac7', '\u0ac8', 0, 0), ('\u0acd', '\u0acd', 0, 0), ('\u0ae2', '\u0ae3', 0, 0),
+ ('\u0b01', '\u0b01', 0, 0), ('\u0b3c', '\u0b3c', 0, 0), ('\u0b3f', '\u0b3f', 0, 0),
+ ('\u0b41', '\u0b44', 0, 0), ('\u0b4d', '\u0b4d', 0, 0), ('\u0b56', '\u0b56', 0, 0),
+ ('\u0b62', '\u0b63', 0, 0), ('\u0b82', '\u0b82', 0, 0), ('\u0bc0', '\u0bc0', 0, 0),
+ ('\u0bcd', '\u0bcd', 0, 0), ('\u0c00', '\u0c00', 0, 0), ('\u0c3e', '\u0c40', 0, 0),
+ ('\u0c46', '\u0c48', 0, 0), ('\u0c4a', '\u0c4d', 0, 0), ('\u0c55', '\u0c56', 0, 0),
+ ('\u0c62', '\u0c63', 0, 0), ('\u0c81', '\u0c81', 0, 0), ('\u0cbc', '\u0cbc', 0, 0),
+ ('\u0cbf', '\u0cbf', 0, 0), ('\u0cc6', '\u0cc6', 0, 0), ('\u0ccc', '\u0ccd', 0, 0),
+ ('\u0ce2', '\u0ce3', 0, 0), ('\u0d01', '\u0d01', 0, 0), ('\u0d41', '\u0d44', 0, 0),
+ ('\u0d4d', '\u0d4d', 0, 0), ('\u0d62', '\u0d63', 0, 0), ('\u0dca', '\u0dca', 0, 0),
+ ('\u0dd2', '\u0dd4', 0, 0), ('\u0dd6', '\u0dd6', 0, 0), ('\u0e31', '\u0e31', 0, 0),
+ ('\u0e34', '\u0e3a', 0, 0), ('\u0e47', '\u0e4e', 0, 0), ('\u0eb1', '\u0eb1', 0, 0),
+ ('\u0eb4', '\u0eb9', 0, 0), ('\u0ebb', '\u0ebc', 0, 0), ('\u0ec8', '\u0ecd', 0, 0),
+ ('\u0f18', '\u0f19', 0, 0), ('\u0f35', '\u0f35', 0, 0), ('\u0f37', '\u0f37', 0, 0),
+ ('\u0f39', '\u0f39', 0, 0), ('\u0f71', '\u0f7e', 0, 0), ('\u0f80', '\u0f84', 0, 0),
+ ('\u0f86', '\u0f87', 0, 0), ('\u0f8d', '\u0f97', 0, 0), ('\u0f99', '\u0fbc', 0, 0),
+ ('\u0fc6', '\u0fc6', 0, 0), ('\u102d', '\u1030', 0, 0), ('\u1032', '\u1037', 0, 0),
+ ('\u1039', '\u103a', 0, 0), ('\u103d', '\u103e', 0, 0), ('\u1058', '\u1059', 0, 0),
+ ('\u105e', '\u1060', 0, 0), ('\u1071', '\u1074', 0, 0), ('\u1082', '\u1082', 0, 0),
+ ('\u1085', '\u1086', 0, 0), ('\u108d', '\u108d', 0, 0), ('\u109d', '\u109d', 0, 0),
+ ('\u1100', '\u115f', 2, 2), ('\u1160', '\u11ff', 0, 0), ('\u135d', '\u135f', 0, 0),
+ ('\u1712', '\u1714', 0, 0), ('\u1732', '\u1734', 0, 0), ('\u1752', '\u1753', 0, 0),
+ ('\u1772', '\u1773', 0, 0), ('\u17b4', '\u17b5', 0, 0), ('\u17b7', '\u17bd', 0, 0),
+ ('\u17c6', '\u17c6', 0, 0), ('\u17c9', '\u17d3', 0, 0), ('\u17dd', '\u17dd', 0, 0),
+ ('\u180b', '\u180e', 0, 0), ('\u18a9', '\u18a9', 0, 0), ('\u1920', '\u1922', 0, 0),
+ ('\u1927', '\u1928', 0, 0), ('\u1932', '\u1932', 0, 0), ('\u1939', '\u193b', 0, 0),
+ ('\u1a17', '\u1a18', 0, 0), ('\u1a1b', '\u1a1b', 0, 0), ('\u1a56', '\u1a56', 0, 0),
+ ('\u1a58', '\u1a5e', 0, 0), ('\u1a60', '\u1a60', 0, 0), ('\u1a62', '\u1a62', 0, 0),
+ ('\u1a65', '\u1a6c', 0, 0), ('\u1a73', '\u1a7c', 0, 0), ('\u1a7f', '\u1a7f', 0, 0),
+ ('\u1ab0', '\u1abe', 0, 0), ('\u1b00', '\u1b03', 0, 0), ('\u1b34', '\u1b34', 0, 0),
+ ('\u1b36', '\u1b3a', 0, 0), ('\u1b3c', '\u1b3c', 0, 0), ('\u1b42', '\u1b42', 0, 0),
+ ('\u1b6b', '\u1b73', 0, 0), ('\u1b80', '\u1b81', 0, 0), ('\u1ba2', '\u1ba5', 0, 0),
+ ('\u1ba8', '\u1ba9', 0, 0), ('\u1bab', '\u1bad', 0, 0), ('\u1be6', '\u1be6', 0, 0),
+ ('\u1be8', '\u1be9', 0, 0), ('\u1bed', '\u1bed', 0, 0), ('\u1bef', '\u1bf1', 0, 0),
+ ('\u1c2c', '\u1c33', 0, 0), ('\u1c36', '\u1c37', 0, 0), ('\u1cd0', '\u1cd2', 0, 0),
+ ('\u1cd4', '\u1ce0', 0, 0), ('\u1ce2', '\u1ce8', 0, 0), ('\u1ced', '\u1ced', 0, 0),
+ ('\u1cf4', '\u1cf4', 0, 0), ('\u1cf8', '\u1cf9', 0, 0), ('\u1dc0', '\u1df5', 0, 0),
+ ('\u1dfc', '\u1dff', 0, 0), ('\u200b', '\u200f', 0, 0), ('\u2010', '\u2010', 1, 2),
+ ('\u2013', '\u2016', 1, 2), ('\u2018', '\u2019', 1, 2), ('\u201c', '\u201d', 1, 2),
+ ('\u2020', '\u2022', 1, 2), ('\u2024', '\u2027', 1, 2), ('\u202a', '\u202e', 0, 0),
+ ('\u2030', '\u2030', 1, 2), ('\u2032', '\u2033', 1, 2), ('\u2035', '\u2035', 1, 2),
+ ('\u203b', '\u203b', 1, 2), ('\u203e', '\u203e', 1, 2), ('\u2060', '\u2064', 0, 0),
+ ('\u2066', '\u206f', 0, 0), ('\u2074', '\u2074', 1, 2), ('\u207f', '\u207f', 1, 2),
+ ('\u2081', '\u2084', 1, 2), ('\u20ac', '\u20ac', 1, 2), ('\u20d0', '\u20f0', 0, 0),
+ ('\u2103', '\u2103', 1, 2), ('\u2105', '\u2105', 1, 2), ('\u2109', '\u2109', 1, 2),
+ ('\u2113', '\u2113', 1, 2), ('\u2116', '\u2116', 1, 2), ('\u2121', '\u2122', 1, 2),
+ ('\u2126', '\u2126', 1, 2), ('\u212b', '\u212b', 1, 2), ('\u2153', '\u2154', 1, 2),
+ ('\u215b', '\u215e', 1, 2), ('\u2160', '\u216b', 1, 2), ('\u2170', '\u2179', 1, 2),
+ ('\u2189', '\u2189', 1, 2), ('\u2190', '\u2199', 1, 2), ('\u21b8', '\u21b9', 1, 2),
+ ('\u21d2', '\u21d2', 1, 2), ('\u21d4', '\u21d4', 1, 2), ('\u21e7', '\u21e7', 1, 2),
+ ('\u2200', '\u2200', 1, 2), ('\u2202', '\u2203', 1, 2), ('\u2207', '\u2208', 1, 2),
+ ('\u220b', '\u220b', 1, 2), ('\u220f', '\u220f', 1, 2), ('\u2211', '\u2211', 1, 2),
+ ('\u2215', '\u2215', 1, 2), ('\u221a', '\u221a', 1, 2), ('\u221d', '\u2220', 1, 2),
+ ('\u2223', '\u2223', 1, 2), ('\u2225', '\u2225', 1, 2), ('\u2227', '\u222c', 1, 2),
+ ('\u222e', '\u222e', 1, 2), ('\u2234', '\u2237', 1, 2), ('\u223c', '\u223d', 1, 2),
+ ('\u2248', '\u2248', 1, 2), ('\u224c', '\u224c', 1, 2), ('\u2252', '\u2252', 1, 2),
+ ('\u2260', '\u2261', 1, 2), ('\u2264', '\u2267', 1, 2), ('\u226a', '\u226b', 1, 2),
+ ('\u226e', '\u226f', 1, 2), ('\u2282', '\u2283', 1, 2), ('\u2286', '\u2287', 1, 2),
+ ('\u2295', '\u2295', 1, 2), ('\u2299', '\u2299', 1, 2), ('\u22a5', '\u22a5', 1, 2),
+ ('\u22bf', '\u22bf', 1, 2), ('\u2312', '\u2312', 1, 2), ('\u2329', '\u232a', 2, 2),
+ ('\u2460', '\u24e9', 1, 2), ('\u24eb', '\u254b', 1, 2), ('\u2550', '\u2573', 1, 2),
+ ('\u2580', '\u258f', 1, 2), ('\u2592', '\u2595', 1, 2), ('\u25a0', '\u25a1', 1, 2),
+ ('\u25a3', '\u25a9', 1, 2), ('\u25b2', '\u25b3', 1, 2), ('\u25b6', '\u25b7', 1, 2),
+ ('\u25bc', '\u25bd', 1, 2), ('\u25c0', '\u25c1', 1, 2), ('\u25c6', '\u25c8', 1, 2),
+ ('\u25cb', '\u25cb', 1, 2), ('\u25ce', '\u25d1', 1, 2), ('\u25e2', '\u25e5', 1, 2),
+ ('\u25ef', '\u25ef', 1, 2), ('\u2605', '\u2606', 1, 2), ('\u2609', '\u2609', 1, 2),
+ ('\u260e', '\u260f', 1, 2), ('\u2614', '\u2615', 1, 2), ('\u261c', '\u261c', 1, 2),
+ ('\u261e', '\u261e', 1, 2), ('\u2640', '\u2640', 1, 2), ('\u2642', '\u2642', 1, 2),
+ ('\u2660', '\u2661', 1, 2), ('\u2663', '\u2665', 1, 2), ('\u2667', '\u266a', 1, 2),
+ ('\u266c', '\u266d', 1, 2), ('\u266f', '\u266f', 1, 2), ('\u269e', '\u269f', 1, 2),
+ ('\u26be', '\u26bf', 1, 2), ('\u26c4', '\u26cd', 1, 2), ('\u26cf', '\u26e1', 1, 2),
+ ('\u26e3', '\u26e3', 1, 2), ('\u26e8', '\u26ff', 1, 2), ('\u273d', '\u273d', 1, 2),
+ ('\u2757', '\u2757', 1, 2), ('\u2776', '\u277f', 1, 2), ('\u2b55', '\u2b59', 1, 2),
+ ('\u2cef', '\u2cf1', 0, 0), ('\u2d7f', '\u2d7f', 0, 0), ('\u2de0', '\u2dff', 0, 0),
+ ('\u2e80', '\u2e99', 2, 2), ('\u2e9b', '\u2ef3', 2, 2), ('\u2f00', '\u2fd5', 2, 2),
+ ('\u2ff0', '\u2ffb', 2, 2), ('\u3000', '\u3029', 2, 2), ('\u302a', '\u302d', 0, 0),
+ ('\u302e', '\u303e', 2, 2), ('\u3041', '\u3096', 2, 2), ('\u3099', '\u309a', 0, 0),
+ ('\u309b', '\u30ff', 2, 2), ('\u3105', '\u312d', 2, 2), ('\u3131', '\u318e', 2, 2),
+ ('\u3190', '\u31ba', 2, 2), ('\u31c0', '\u31e3', 2, 2), ('\u31f0', '\u321e', 2, 2),
+ ('\u3220', '\u3247', 2, 2), ('\u3248', '\u324f', 1, 2), ('\u3250', '\u32fe', 2, 2),
+ ('\u3300', '\u4dbf', 2, 2), ('\u4e00', '\ua48c', 2, 2), ('\ua490', '\ua4c6', 2, 2),
+ ('\ua66f', '\ua672', 0, 0), ('\ua674', '\ua67d', 0, 0), ('\ua69f', '\ua69f', 0, 0),
+ ('\ua6f0', '\ua6f1', 0, 0), ('\ua802', '\ua802', 0, 0), ('\ua806', '\ua806', 0, 0),
+ ('\ua80b', '\ua80b', 0, 0), ('\ua825', '\ua826', 0, 0), ('\ua8c4', '\ua8c4', 0, 0),
+ ('\ua8e0', '\ua8f1', 0, 0), ('\ua926', '\ua92d', 0, 0), ('\ua947', '\ua951', 0, 0),
+ ('\ua960', '\ua97c', 2, 2), ('\ua980', '\ua982', 0, 0), ('\ua9b3', '\ua9b3', 0, 0),
+ ('\ua9b6', '\ua9b9', 0, 0), ('\ua9bc', '\ua9bc', 0, 0), ('\ua9e5', '\ua9e5', 0, 0),
+ ('\uaa29', '\uaa2e', 0, 0), ('\uaa31', '\uaa32', 0, 0), ('\uaa35', '\uaa36', 0, 0),
+ ('\uaa43', '\uaa43', 0, 0), ('\uaa4c', '\uaa4c', 0, 0), ('\uaa7c', '\uaa7c', 0, 0),
+ ('\uaab0', '\uaab0', 0, 0), ('\uaab2', '\uaab4', 0, 0), ('\uaab7', '\uaab8', 0, 0),
+ ('\uaabe', '\uaabf', 0, 0), ('\uaac1', '\uaac1', 0, 0), ('\uaaec', '\uaaed', 0, 0),
+ ('\uaaf6', '\uaaf6', 0, 0), ('\uabe5', '\uabe5', 0, 0), ('\uabe8', '\uabe8', 0, 0),
+ ('\uabed', '\uabed', 0, 0), ('\uac00', '\ud7a3', 2, 2), ('\ue000', '\uf8ff', 1, 2),
+ ('\uf900', '\ufaff', 2, 2), ('\ufb1e', '\ufb1e', 0, 0), ('\ufe00', '\ufe0f', 0, 0),
+ ('\ufe10', '\ufe19', 2, 2), ('\ufe20', '\ufe2d', 0, 0), ('\ufe30', '\ufe52', 2, 2),
+ ('\ufe54', '\ufe66', 2, 2), ('\ufe68', '\ufe6b', 2, 2), ('\ufeff', '\ufeff', 0, 0),
+ ('\uff01', '\uff60', 2, 2), ('\uffe0', '\uffe6', 2, 2), ('\ufff9', '\ufffb', 0, 0),
+ ('\ufffd', '\ufffd', 1, 2), ('\U000101fd', '\U000101fd', 0, 0), ('\U000102e0', '\U000102e0',
+ 0, 0), ('\U00010376', '\U0001037a', 0, 0), ('\U00010a01', '\U00010a03', 0, 0),
+ ('\U00010a05', '\U00010a06', 0, 0), ('\U00010a0c', '\U00010a0f', 0, 0), ('\U00010a38',
+ '\U00010a3a', 0, 0), ('\U00010a3f', '\U00010a3f', 0, 0), ('\U00010ae5', '\U00010ae6', 0, 0),
+ ('\U00011001', '\U00011001', 0, 0), ('\U00011038', '\U00011046', 0, 0), ('\U0001107f',
+ '\U00011081', 0, 0), ('\U000110b3', '\U000110b6', 0, 0), ('\U000110b9', '\U000110ba', 0, 0),
+ ('\U000110bd', '\U000110bd', 0, 0), ('\U00011100', '\U00011102', 0, 0), ('\U00011127',
+ '\U0001112b', 0, 0), ('\U0001112d', '\U00011134', 0, 0), ('\U00011173', '\U00011173', 0, 0),
+ ('\U00011180', '\U00011181', 0, 0), ('\U000111b6', '\U000111be', 0, 0), ('\U0001122f',
+ '\U00011231', 0, 0), ('\U00011234', '\U00011234', 0, 0), ('\U00011236', '\U00011237', 0, 0),
+ ('\U000112df', '\U000112df', 0, 0), ('\U000112e3', '\U000112ea', 0, 0), ('\U00011301',
+ '\U00011301', 0, 0), ('\U0001133c', '\U0001133c', 0, 0), ('\U00011340', '\U00011340', 0, 0),
+ ('\U00011366', '\U0001136c', 0, 0), ('\U00011370', '\U00011374', 0, 0), ('\U000114b3',
+ '\U000114b8', 0, 0), ('\U000114ba', '\U000114ba', 0, 0), ('\U000114bf', '\U000114c0', 0, 0),
+ ('\U000114c2', '\U000114c3', 0, 0), ('\U000115b2', '\U000115b5', 0, 0), ('\U000115bc',
+ '\U000115bd', 0, 0), ('\U000115bf', '\U000115c0', 0, 0), ('\U00011633', '\U0001163a', 0, 0),
+ ('\U0001163d', '\U0001163d', 0, 0), ('\U0001163f', '\U00011640', 0, 0), ('\U000116ab',
+ '\U000116ab', 0, 0), ('\U000116ad', '\U000116ad', 0, 0), ('\U000116b0', '\U000116b5', 0, 0),
+ ('\U000116b7', '\U000116b7', 0, 0), ('\U00016af0', '\U00016af4', 0, 0), ('\U00016b30',
+ '\U00016b36', 0, 0), ('\U00016f8f', '\U00016f92', 0, 0), ('\U0001b000', '\U0001b001', 2, 2),
+ ('\U0001bc9d', '\U0001bc9e', 0, 0), ('\U0001bca0', '\U0001bca3', 0, 0), ('\U0001d167',
+ '\U0001d169', 0, 0), ('\U0001d173', '\U0001d182', 0, 0), ('\U0001d185', '\U0001d18b', 0, 0),
+ ('\U0001d1aa', '\U0001d1ad', 0, 0), ('\U0001d242', '\U0001d244', 0, 0), ('\U0001e8d0',
+ '\U0001e8d6', 0, 0), ('\U0001f100', '\U0001f10a', 1, 2), ('\U0001f110', '\U0001f12d', 1, 2),
+ ('\U0001f130', '\U0001f169', 1, 2), ('\U0001f170', '\U0001f19a', 1, 2), ('\U0001f200',
+ '\U0001f202', 2, 2), ('\U0001f210', '\U0001f23a', 2, 2), ('\U0001f240', '\U0001f248', 2, 2),
+ ('\U0001f250', '\U0001f251', 2, 2), ('\U00020000', '\U0002fffd', 2, 2), ('\U00030000',
+ '\U0003fffd', 2, 2), ('\U000e0001', '\U000e0001', 0, 0), ('\U000e0020', '\U000e007f', 0, 0),
+ ('\U000e0100', '\U000e01ef', 0, 0), ('\U000f0000', '\U000ffffd', 1, 2), ('\U00100000',
+ '\U0010fffd', 1, 2)
+ ];
+
+}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+ * Unicode-intensive `char` methods.
+ *
+ * These methods implement functionality for `char` that requires knowledge of
+ * Unicode definitions, including normalization, categorization, and display information.
+ */
+
+use core::option::Option;
+use tables::{derived_property, property, general_category, conversions, charwidth};
+
+/// Returns whether the specified `char` is considered a Unicode alphabetic
+/// code point
+pub fn is_alphabetic(c: char) -> bool { derived_property::Alphabetic(c) }
+
+/// Returns whether the specified `char` satisfies the 'XID_Start' Unicode property
+///
+/// 'XID_Start' is a Unicode Derived Property specified in
+/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
+/// mostly similar to ID_Start but modified for closure under NFKx.
+#[allow(non_snake_case_functions)]
+pub fn is_XID_start(c: char) -> bool { derived_property::XID_Start(c) }
+
+/// Returns whether the specified `char` satisfies the 'XID_Continue' Unicode property
+///
+/// 'XID_Continue' is a Unicode Derived Property specified in
+/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
+/// mostly similar to 'ID_Continue' but modified for closure under NFKx.
+#[allow(non_snake_case_functions)]
+pub fn is_XID_continue(c: char) -> bool { derived_property::XID_Continue(c) }
+
+///
+/// Indicates whether a `char` is in lower case
+///
+/// This is defined according to the terms of the Unicode Derived Core Property 'Lowercase'.
+///
+#[inline]
+pub fn is_lowercase(c: char) -> bool { derived_property::Lowercase(c) }
+
+///
+/// Indicates whether a `char` is in upper case
+///
+/// This is defined according to the terms of the Unicode Derived Core Property 'Uppercase'.
+///
+#[inline]
+pub fn is_uppercase(c: char) -> bool { derived_property::Uppercase(c) }
+
+///
+/// Indicates whether a `char` is whitespace
+///
+/// Whitespace is defined in terms of the Unicode Property 'White_Space'.
+///
+#[inline]
+pub fn is_whitespace(c: char) -> bool {
+ // As an optimization ASCII whitespace characters are checked separately
+ c == ' '
+ || ('\x09' <= c && c <= '\x0d')
+ || property::White_Space(c)
+}
+
+///
+/// Indicates whether a `char` is alphanumeric
+///
+/// Alphanumericness is defined in terms of the Unicode General Categories
+/// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
+///
+#[inline]
+pub fn is_alphanumeric(c: char) -> bool {
+ derived_property::Alphabetic(c)
+ || general_category::N(c)
+}
+
+///
+/// Indicates whether a `char` is a control code point
+///
+/// Control code points are defined in terms of the Unicode General Category
+/// 'Cc'.
+///
+#[inline]
+pub fn is_control(c: char) -> bool { general_category::Cc(c) }
+
+/// Indicates whether the `char` is numeric (Nd, Nl, or No)
+#[inline]
+pub fn is_digit(c: char) -> bool {
+ general_category::N(c)
+}
+
+/// Convert a char to its uppercase equivalent
+///
+/// The case-folding performed is the common or simple mapping:
+/// it maps one unicode codepoint (one char in Rust) to its uppercase equivalent according
+/// to the Unicode database at ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
+/// The additional SpecialCasing.txt is not considered here, as it expands to multiple
+/// codepoints in some cases.
+///
+/// A full reference can be found here
+/// http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992
+///
+/// # Return value
+///
+/// Returns the char itself if no conversion was made
+#[inline]
+pub fn to_uppercase(c: char) -> char {
+ conversions::to_upper(c)
+}
+
+/// Convert a char to its lowercase equivalent
+///
+/// The case-folding performed is the common or simple mapping
+/// see `to_uppercase` for references and more information
+///
+/// # Return value
+///
+/// Returns the char itself if no conversion if possible
+#[inline]
+pub fn to_lowercase(c: char) -> char {
+ conversions::to_lower(c)
+}
+
+/// Returns this character's displayed width in columns, or `None` if it is a
+/// control character other than `'\x00'`.
+///
+/// `is_cjk` determines behavior for characters in the Ambiguous category:
+/// if `is_cjk` is `true`, these are 2 columns wide; otherwise, they are 1.
+/// In CJK contexts, `is_cjk` should be `true`, else it should be `false`.
+/// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
+/// recommends that these characters be treated as 1 column (i.e.,
+/// `is_cjk` = `false`) if the context cannot be reliably determined.
+pub fn width(c: char, is_cjk: bool) -> Option<uint> {
+ charwidth::width(c, is_cjk)
+}
+
+/// Useful functions for Unicode characters.
+pub trait UnicodeChar {
+ /// Returns whether the specified character is considered a Unicode
+ /// alphabetic code point.
+ fn is_alphabetic(&self) -> bool;
+
+ /// Returns whether the specified character satisfies the 'XID_Start'
+ /// Unicode property.
+ ///
+ /// 'XID_Start' is a Unicode Derived Property specified in
+ /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
+ /// mostly similar to ID_Start but modified for closure under NFKx.
+ #[allow(non_snake_case_functions)]
+ fn is_XID_start(&self) -> bool;
+
+ /// Returns whether the specified `char` satisfies the 'XID_Continue'
+ /// Unicode property.
+ ///
+ /// 'XID_Continue' is a Unicode Derived Property specified in
+ /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
+ /// mostly similar to 'ID_Continue' but modified for closure under NFKx.
+ #[allow(non_snake_case_functions)]
+ fn is_XID_continue(&self) -> bool;
+
+
+ /// Indicates whether a character is in lowercase.
+ ///
+ /// This is defined according to the terms of the Unicode Derived Core
+ /// Property `Lowercase`.
+ fn is_lowercase(&self) -> bool;
+
+ /// Indicates whether a character is in uppercase.
+ ///
+ /// This is defined according to the terms of the Unicode Derived Core
+ /// Property `Uppercase`.
+ fn is_uppercase(&self) -> bool;
+
+ /// Indicates whether a character is whitespace.
+ ///
+ /// Whitespace is defined in terms of the Unicode Property `White_Space`.
+ fn is_whitespace(&self) -> bool;
+
+ /// Indicates whether a character is alphanumeric.
+ ///
+ /// Alphanumericness is defined in terms of the Unicode General Categories
+ /// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
+ fn is_alphanumeric(&self) -> bool;
+
+ /// Indicates whether a character is a control code point.
+ ///
+ /// Control code points are defined in terms of the Unicode General
+ /// Category `Cc`.
+ fn is_control(&self) -> bool;
+
+ /// Indicates whether the character is numeric (Nd, Nl, or No).
+ fn is_digit(&self) -> bool;
+
+ /// Converts a character to its lowercase equivalent.
+ ///
+ /// The case-folding performed is the common or simple mapping. See
+ /// `to_uppercase()` for references and more information.
+ ///
+ /// # Return value
+ ///
+ /// Returns the lowercase equivalent of the character, or the character
+ /// itself if no conversion is possible.
+ fn to_lowercase(&self) -> char;
+
+ /// Converts a character to its uppercase equivalent.
+ ///
+ /// The case-folding performed is the common or simple mapping: it maps
+ /// one unicode codepoint (one character in Rust) to its uppercase
+ /// equivalent according to the Unicode database [1]. The additional
+ /// `SpecialCasing.txt` is not considered here, as it expands to multiple
+ /// codepoints in some cases.
+ ///
+ /// A full reference can be found here [2].
+ ///
+ /// # Return value
+ ///
+ /// Returns the uppercase equivalent of the character, or the character
+ /// itself if no conversion was made.
+ ///
+ /// [1]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
+ ///
+ /// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992
+ fn to_uppercase(&self) -> char;
+
+ /// Returns this character's displayed width in columns, or `None` if it is a
+ /// control character other than `'\x00'`.
+ ///
+ /// `is_cjk` determines behavior for characters in the Ambiguous category:
+ /// if `is_cjk` is `true`, these are 2 columns wide; otherwise, they are 1.
+ /// In CJK contexts, `is_cjk` should be `true`, else it should be `false`.
+ /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
+ /// recommends that these characters be treated as 1 column (i.e.,
+ /// `is_cjk` = `false`) if the context cannot be reliably determined.
+ fn width(&self, is_cjk: bool) -> Option<uint>;
+}
+
+impl UnicodeChar for char {
+ fn is_alphabetic(&self) -> bool { is_alphabetic(*self) }
+
+ fn is_XID_start(&self) -> bool { is_XID_start(*self) }
+
+ fn is_XID_continue(&self) -> bool { is_XID_continue(*self) }
+
+ fn is_lowercase(&self) -> bool { is_lowercase(*self) }
+
+ fn is_uppercase(&self) -> bool { is_uppercase(*self) }
+
+ fn is_whitespace(&self) -> bool { is_whitespace(*self) }
+
+ fn is_alphanumeric(&self) -> bool { is_alphanumeric(*self) }
+
+ fn is_control(&self) -> bool { is_control(*self) }
+
+ fn is_digit(&self) -> bool { is_digit(*self) }
+
+ fn to_lowercase(&self) -> char { to_lowercase(*self) }
+
+ fn to_uppercase(&self) -> char { to_uppercase(*self) }
+
+ fn width(&self, is_cjk: bool) -> Option<uint> { width(*self, is_cjk) }
+}
--- /dev/null
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+ * Unicode-intensive string manipulations.
+ *
+ * This module provides functionality to `str` that requires the Unicode
+ * methods provided by the UnicodeChar trait.
+ */
+
+use core::collections::Collection;
+use core::iter::{Filter};
+use core::str::{CharSplits, StrSlice};
+use core::iter::Iterator;
+use u_char;
+
+/// An iterator over the words of a string, separated by a sequence of whitespace
+pub type Words<'a> =
+ Filter<'a, &'a str, CharSplits<'a, extern "Rust" fn(char) -> bool>>;
+
+/// Methods for Unicode string slices
+pub trait UnicodeStrSlice<'a> {
+ /// An iterator over the words of a string (subsequences separated
+ /// by any sequence of whitespace). Sequences of whitespace are
+ /// collapsed, so empty "words" are not included.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// let some_words = " Mary had\ta little \n\t lamb";
+ /// let v: Vec<&str> = some_words.words().collect();
+ /// assert_eq!(v, vec!["Mary", "had", "a", "little", "lamb"]);
+ /// ```
+ fn words(&self) -> Words<'a>;
+
+ /// Returns true if the string contains only whitespace.
+ ///
+ /// Whitespace characters are determined by `char::is_whitespace`.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// assert!(" \t\n".is_whitespace());
+ /// assert!("".is_whitespace());
+ ///
+ /// assert!( !"abc".is_whitespace());
+ /// ```
+ fn is_whitespace(&self) -> bool;
+
+ /// Returns true if the string contains only alphanumeric code
+ /// points.
+ ///
+ /// Alphanumeric characters are determined by `char::is_alphanumeric`.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// assert!("Löwe老虎Léopard123".is_alphanumeric());
+ /// assert!("".is_alphanumeric());
+ ///
+ /// assert!( !" &*~".is_alphanumeric());
+ /// ```
+ fn is_alphanumeric(&self) -> bool;
+
+ /// Returns a string's displayed width in columns, treating control
+ /// characters as zero-width.
+ ///
+ /// `is_cjk` determines behavior for characters in the Ambiguous category:
+ /// if `is_cjk` is `true`, these are 2 columns wide; otherwise, they are 1.
+ /// In CJK locales, `is_cjk` should be `true`, else it should be `false`.
+ /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
+ /// recommends that these characters be treated as 1 column (i.e.,
+ /// `is_cjk` = `false`) if the locale is unknown.
+ //fn width(&self, is_cjk: bool) -> uint;
+
+ /// Returns a string with leading and trailing whitespace removed.
+ fn trim(&self) -> &'a str;
+
+ /// Returns a string with leading whitespace removed.
+ fn trim_left(&self) -> &'a str;
+
+ /// Returns a string with trailing whitespace removed.
+ fn trim_right(&self) -> &'a str;
+}
+
+impl<'a> UnicodeStrSlice<'a> for &'a str {
+ #[inline]
+ fn words(&self) -> Words<'a> {
+ self.split(u_char::is_whitespace).filter(|s| !s.is_empty())
+ }
+
+ #[inline]
+ fn is_whitespace(&self) -> bool { self.chars().all(u_char::is_whitespace) }
+
+ #[inline]
+ fn is_alphanumeric(&self) -> bool { self.chars().all(u_char::is_alphanumeric) }
+
+ #[inline]
+ fn trim(&self) -> &'a str {
+ self.trim_left().trim_right()
+ }
+
+ #[inline]
+ fn trim_left(&self) -> &'a str {
+ self.trim_left_chars(u_char::is_whitespace)
+ }
+
+ #[inline]
+ fn trim_right(&self) -> &'a str {
+ self.trim_right_chars(u_char::is_whitespace)
+ }
+}
//! Types/fns concerning URLs (see RFC 3986)
-#![crate_id = "url#0.11.0"] // NOTE: remove after stage0
#![crate_name = "url"]
#![experimental]
#![crate_type = "rlib"]
html_root_url = "http://doc.rust-lang.org/0.11.0/",
html_playground_url = "http://play.rust-lang.org/")]
#![feature(default_type_params)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
use std::collections::HashMap;
use std::fmt;
*/
-#![crate_id = "uuid#0.11.0"] // NOTE: remove after stage0
#![crate_name = "uuid"]
#![experimental]
#![crate_type = "rlib"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/0.11.0/",
html_playground_url = "http://play.rust-lang.org/")]
-#![allow(unused_attribute)] // NOTE: remove after stage0
#![feature(default_type_params)]
+S 2014-07-09 8ddd286
+ freebsd-x86_64 de0c39057f409b69e5ddb888ba3e20b90d63f5db
+ linux-i386 28bef31f2a017e1998256d0c2b2e0a0c9221451b
+ linux-x86_64 853bd73501a10d49cafdf823110c61f13a3392d6
+ macos-i386 b89540ae54f9e565565d36147a586bb4bfbd861b
+ macos-x86_64 58709eb936e7fd66a28a1bb82aaf43a4d8260dea
+ winnt-i386 64a32dcb008d4590a6c6a9efaffbe1d22a334d34
+
S 2014-07-05 aaff4e0
freebsd-x86_64 10272ca9eb17e1be4a4b172aacfb4b33fffcc8fb
linux-i386 72ba9f6e0d096c30f128cb3736ffac0b57530a20
--- /dev/null
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// no-prefer-dynamic
+
+#![crate_type = "rlib"]
+#![feature(plugin_registrar)]
+
+extern crate rustc;
+
+use rustc::plugin::Registry;
+
+#[plugin_registrar]
+pub fn plugin_registrar(_: &mut Registry) {}
--- /dev/null
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:rlib_crate_test.rs
+// ignore-stage1
+// ignore-tidy-linelength
+// ignore-android
+
+#![feature(phase)]
+#[phase(plugin)] extern crate rlib_crate_test;
+//~^ ERROR: plugin crate `rlib_crate_test` only found in rlib format, but must be available in dylib format
+
+fn main() {}
extern crate macro_crate_test;
fn main() {
- assert_eq!(3, unexported_macro!()); //~ ERROR macro undefined: 'unexported_macro'
+ assert_eq!(3, unexported_macro!()); //~ ERROR macro undefined: 'unexported_macro!'
}
fn main() {
print!(test!());
- //~^ ERROR: macro undefined: 'test'
+ //~^ ERROR: macro undefined: 'test!'
//~^^ ERROR: format argument must be a string literal
concat!(test!());
- //~^ ERROR: macro undefined: 'test'
+ //~^ ERROR: macro undefined: 'test!'
}
let x = -2147483648_i32; // should be OK
let x: i32 = -2147483649; //~ error: literal out of range for its type
let x = -2147483649_i32; //~ error: literal out of range for its type
+
+ let x = -3.40282348e+38_f32; //~ error: literal out of range for its type
+ let x = 3.40282348e+38_f32; //~ error: literal out of range for its type
+ let x = -1.7976931348623159e+308_f64; //~ error: literal out of range for its type
+ let x = 1.7976931348623159e+308_f64; //~ error: literal out of range for its type
}
fn main() {
let a: Vec<int> = Vec::new();
- a.iter().advance(|_| -> bool {
+ a.iter().all(|_| -> bool {
//~^ ERROR mismatched types
});
}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(rustc_diagnostic_macros)]
+
+__register_diagnostic!(E0001)
+__register_diagnostic!(E0003)
+
+fn main() {
+ __diagnostic_used!(E0002);
+ //~^ ERROR unknown diagnostic code E0002
+
+ __diagnostic_used!(E0001);
+ //~^ NOTE previous invocation
+
+ __diagnostic_used!(E0001);
+ //~^ WARNING diagnostic code E0001 already used
+}
+
+__build_diagnostic_array!(DIAGNOSTICS)
+//~^ WARN diagnostic code E0003 never used
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(rustc_diagnostic_macros)]
+
+__register_diagnostic!(E0001)
+__register_diagnostic!(E0001)
+//~^ ERROR diagnostic code E0001 already registered
+
+fn main() {
+}
+
+__build_diagnostic_array!(DIAGNOSTICS)
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+__register_diagnostic!(E0001)
+//~^ ERROR macro undefined: '__register_diagnostic!'
+
+fn main() {
+ __diagnostic_used!(E0001);
+ //~^ ERROR macro undefined: '__diagnostic_used!'
+}
+
+__build_diagnostic_array!(DIAGNOSTICS)
+//~^ ERROR macro undefined: '__build_diagnostic_array!'
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let x : i16 = 22;
+ ((&x) as *const i16) as f32;
+ //~^ ERROR: cannot cast from pointer to float directly: `*const i16` as `f32`
+}
#[must_use]
enum MustUse { Test }
+#[must_use = "some message"]
+enum MustUseMsg { Test2 }
+
fn foo<T>() -> T { fail!() }
fn bar() -> int { return foo::<int>(); }
fn baz() -> MustUse { return foo::<MustUse>(); }
+fn qux() -> MustUseMsg { return foo::<MustUseMsg>(); }
#[allow(unused_result)]
fn test() {
foo::<int>();
foo::<MustUse>(); //~ ERROR: unused result which must be used
+ foo::<MustUseMsg>(); //~ ERROR: unused result which must be used: some message
}
#[allow(unused_result, unused_must_use)]
fn test2() {
foo::<int>();
foo::<MustUse>();
+ foo::<MustUseMsg>();
}
fn main() {
foo::<int>(); //~ ERROR: unused result
foo::<MustUse>(); //~ ERROR: unused result which must be used
+ foo::<MustUseMsg>(); //~ ERROR: unused result which must be used: some message
let _ = foo::<int>();
let _ = foo::<MustUse>();
+ let _ = foo::<MustUseMsg>();
}
impl<'a,A> iterable<A> for &'a [A] {
fn iterate(&self, f: |x: &A| -> bool) -> bool {
- self.iter().advance(f)
+ self.iter().all(f)
}
}
impl<A> iterable<A> for Vec<A> {
fn iterate(&self, f: |x: &A| -> bool) -> bool {
- self.iter().advance(f)
+ self.iter().all(f)
}
}
}
fn runtest(me: &str) {
- let mut env = os::env().move_iter()
- .map(|(ref k, ref v)| {
- (k.to_string(), v.to_string())
- }).collect::<Vec<(String,String)>>();
- match env.iter()
- .position(|&(ref s, _)| "RUST_BACKTRACE" == s.as_slice()) {
- Some(i) => { env.remove(i); }
- None => {}
- }
- env.push(("RUST_BACKTRACE".to_string(), "1".to_string()));
-
// Make sure that the stack trace is printed
- let mut p = Command::new(me).arg("fail").env(env.as_slice()).spawn().unwrap();
+ let mut p = Command::new(me).arg("fail").env("RUST_BACKTRACE", "1").spawn().unwrap();
let out = p.wait_with_output().unwrap();
assert!(!out.status.success());
let s = str::from_utf8(out.error.as_slice()).unwrap();
"bad output3: {}", s);
// Make sure a stack trace isn't printed too many times
- let mut p = Command::new(me).arg("double-fail").env(env.as_slice()).spawn().unwrap();
+ let mut p = Command::new(me).arg("double-fail")
+ .env("RUST_BACKTRACE", "1").spawn().unwrap();
let out = p.wait_with_output().unwrap();
assert!(!out.status.success());
let s = str::from_utf8(out.error.as_slice()).unwrap();
fn iter_ints(x: &Ints, f: |x: &int| -> bool) -> bool {
let l = x.values.len();
- range(0u, l).advance(|i| f(x.values.get(i)))
+ range(0u, l).all(|i| f(x.values.get(i)))
}
pub fn main() {
let p = Command::new(&child_path)
.arg(arg)
.cwd(&cwd)
- .env(my_env.append_one(env).as_slice())
+ .env_set_all(my_env.append_one(env).as_slice())
.spawn().unwrap().wait_with_output().unwrap();
// display the output
projects / rust.git / commitdiff