From 4e9e091e91ea2ad8a6f45a9b20ff331d4bca7a23 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 16 May 2014 14:23:04 -0700 Subject: syntax: Tighten search paths for inner modules This is an implementation of RFC 16. A module can now only be loaded if the module declaring `mod name;` "owns" the current directory. A module is considered as owning its directory if it meets one of the following criteria: * It is the top-level crate file * It is a `mod.rs` file * It was loaded via `#[path]` * It was loaded via `include!` * The module was declared via an inline `mod foo { ... }` statement For example, this directory structure is now invalid // lib.rs mod foo; // foo.rs mod bar; // bar.rs; fn bar() {} With this change `foo.rs` must be renamed to `foo/mod.rs`, and `bar.rs` must be renamed to `foo/bar.rs`. This makes it clear that `bar` is a submodule of `foo`, and can only be accessed through `foo`. RFC: 0016-module-file-system-hierarchy Closes #14180 [breaking-change] --- src/libregex/parse.rs | 1030 ---- src/libregex/parse/mod.rs | 1030 ++++ src/libregex/parse/unicode.rs | 5537 ++++++++++++++++++++ src/libregex/unicode.rs | 5537 -------------------- src/libsyntax/ext/deriving/generic.rs | 1304 ----- src/libsyntax/ext/deriving/generic/mod.rs | 1304 +++++ src/libsyntax/ext/deriving/generic/ty.rs | 267 + src/libsyntax/ext/deriving/ty.rs | 267 - src/libsyntax/ext/source_util.rs | 2 + src/libsyntax/parse/mod.rs | 7 +- src/libsyntax/parse/parser.rs | 50 +- src/test/compile-fail/circular_modules_main.rs | 2 +- src/test/compile-fail/mod_file_not_owning.rs | 15 + src/test/compile-fail/mod_file_not_owning_aux1.rs | 13 + src/test/compile-fail/mod_file_not_owning_aux2.rs | 11 + .../run-pass/mod_dir_simple/load_another_mod.rs | 1 + 16 files changed, 8231 insertions(+), 8146 deletions(-) delete mode 100644 src/libregex/parse.rs create mode 100644 src/libregex/parse/mod.rs create mode 100644 src/libregex/parse/unicode.rs delete mode 100644 src/libregex/unicode.rs delete mode 100644 src/libsyntax/ext/deriving/generic.rs create mode 100644 src/libsyntax/ext/deriving/generic/mod.rs create mode 100644 src/libsyntax/ext/deriving/generic/ty.rs delete mode 100644 src/libsyntax/ext/deriving/ty.rs create mode 100644 src/test/compile-fail/mod_file_not_owning.rs create mode 100644 src/test/compile-fail/mod_file_not_owning_aux1.rs create mode 100644 src/test/compile-fail/mod_file_not_owning_aux2.rs (limited to 'src') diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs deleted file mode 100644 index a695da9fa16..00000000000 --- a/src/libregex/parse.rs +++ /dev/null @@ -1,1030 +0,0 @@ -// 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 or the MIT license -// , 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: StrBuf, -} - -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, Box), - // Represent concatenation as a flat vector to avoid blowing the - // stack in the compiler. - Cat(Vec), - Alt(Box, Box), - Rep(Box, Repeater, Greed), -} - -#[deriving(Show, Eq, 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, StrBuf), // '(' - 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 { - match *self { - Paren(_, 0, _) => None, - Paren(_, c, _) => Some(c), - _ => fail!("Cannot get capture group from {}", self), - } - } - - fn capture_name(&self) -> Option { - 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 { - 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, - // The index of the current character in the input. - chari: uint, - // The intermediate state representing the AST. - stack: Vec, - // 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, -} - -pub fn parse(s: &str) -> Result { - 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 { - 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_strbuf())) - } - } - ')' => { - 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)), - } - } - - 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())), - false => self.err(format!("Expected '{}' but got EOF.", expected)), - } - } - - fn next_char(&mut self) -> bool { - self.chari += 1; - self.chari < self.chars.len() - } - - fn pop_ast(&mut self) -> Result { - 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> { - match c { - '.' => { - self.push(Dot(self.flags)) - } - '^' => { - self.push(Begin(self.flags)) - } - '$' => { - self.push(End(self.flags)) - } - _ => { - self.push(Literal(c, self.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 = 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)) - } - 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 { - 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)), - }; - 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); - if !inner.contains(",") { - min = try!(self.parse_uint(inner)); - max = Some(min); - } else { - let pieces: Vec<&str> = inner.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)); - } - if max.is_some() { - let m = max.unwrap(); - if m > MAX_REPEAT { - return self.err(format!( - "{} exceeds maximum allowed repetitions ({})", - m, MAX_REPEAT)); - } - if m < min { - return self.err(format!( - "Max repetitions ({}) cannot be smaller than min \ - repetitions ({}).", m, min)); - } - } - - // 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 { - 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)), - } - } - - // 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 { - let negated = if self.cur() == 'P' { FLAG_NEGATED } else { FLAG_EMPTY }; - let mut name: StrBuf; - 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)), - }; - 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)), - 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 { - 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::(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)), - } - } - - // Parse a hex number. Either exactly two digits or anything in {}. - // Assumes that \x has been read. - fn parse_hex(&mut self) -> Result { - 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)), - 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 { - 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))) - self.parse_hex_digits(self.slice(start, end).as_slice()) - } - - // Parses `s` as a hexadecimal number. - fn parse_hex_digits(&self, s: &str) -> Result { - match num::from_str_radix::(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)), - } - } - - // 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)) - } - 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 = 1; - 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))) - } - 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))) - } - flags = flags ^ flags; - } - if self.cur() == ':' { - // Save the old flags with the opening paren. - self.stack.push(Paren(self.flags, 0, "".to_strbuf())); - } - self.flags = flags; - return Ok(()) - } - _ => return self.err(format!( - "Unrecognized flag '{}'.", self.cur())), - } - } - } - - // 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 { - 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 { - 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 { - 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 { - match from_str::(s) { - Some(i) => Ok(i), - None => self.err(format!( - "Expected an unsigned integer but got '{}'.", s)), - } - } - - fn char_from_u32(&self, n: u32) -> Result { - match char::from_u32(n) { - Some(c) => Ok(c), - None => self.err(format!( - "Could not decode '{}' to unicode character.", n)), - } - } - - fn pos(&self, c: char) -> Option { - self.chars.iter() - .skip(self.chari).position(|&c2| c2 == c).map(|i| self.chari + i) - } - - fn err(&self, msg: &str) -> Result { - Err(Error { - pos: self.chari, - msg: msg.to_strbuf(), - }) - } - - fn peek(&self, offset: uint) -> Option { - 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) -> StrBuf { - str::from_chars(self.chars.as_slice().slice(start, end)).to_strbuf() - } -} - -// 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 = 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> { - 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')]), -]; diff --git a/src/libregex/parse/mod.rs b/src/libregex/parse/mod.rs new file mode 100644 index 00000000000..a695da9fa16 --- /dev/null +++ b/src/libregex/parse/mod.rs @@ -0,0 +1,1030 @@ +// 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 or the MIT license +// , 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: StrBuf, +} + +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, Box), + // Represent concatenation as a flat vector to avoid blowing the + // stack in the compiler. + Cat(Vec), + Alt(Box, Box), + Rep(Box, Repeater, Greed), +} + +#[deriving(Show, Eq, 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, StrBuf), // '(' + 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 { + match *self { + Paren(_, 0, _) => None, + Paren(_, c, _) => Some(c), + _ => fail!("Cannot get capture group from {}", self), + } + } + + fn capture_name(&self) -> Option { + 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 { + 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, + // The index of the current character in the input. + chari: uint, + // The intermediate state representing the AST. + stack: Vec, + // 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, +} + +pub fn parse(s: &str) -> Result { + 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 { + 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_strbuf())) + } + } + ')' => { + 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)), + } + } + + 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())), + false => self.err(format!("Expected '{}' but got EOF.", expected)), + } + } + + fn next_char(&mut self) -> bool { + self.chari += 1; + self.chari < self.chars.len() + } + + fn pop_ast(&mut self) -> Result { + 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> { + match c { + '.' => { + self.push(Dot(self.flags)) + } + '^' => { + self.push(Begin(self.flags)) + } + '$' => { + self.push(End(self.flags)) + } + _ => { + self.push(Literal(c, self.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 = 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)) + } + 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 { + 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)), + }; + 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); + if !inner.contains(",") { + min = try!(self.parse_uint(inner)); + max = Some(min); + } else { + let pieces: Vec<&str> = inner.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)); + } + if max.is_some() { + let m = max.unwrap(); + if m > MAX_REPEAT { + return self.err(format!( + "{} exceeds maximum allowed repetitions ({})", + m, MAX_REPEAT)); + } + if m < min { + return self.err(format!( + "Max repetitions ({}) cannot be smaller than min \ + repetitions ({}).", m, min)); + } + } + + // 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 { + 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)), + } + } + + // 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 { + let negated = if self.cur() == 'P' { FLAG_NEGATED } else { FLAG_EMPTY }; + let mut name: StrBuf; + 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)), + }; + 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)), + 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 { + 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::(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)), + } + } + + // Parse a hex number. Either exactly two digits or anything in {}. + // Assumes that \x has been read. + fn parse_hex(&mut self) -> Result { + 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)), + 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 { + 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))) + self.parse_hex_digits(self.slice(start, end).as_slice()) + } + + // Parses `s` as a hexadecimal number. + fn parse_hex_digits(&self, s: &str) -> Result { + match num::from_str_radix::(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)), + } + } + + // 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)) + } + 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 = 1; + 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))) + } + 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))) + } + flags = flags ^ flags; + } + if self.cur() == ':' { + // Save the old flags with the opening paren. + self.stack.push(Paren(self.flags, 0, "".to_strbuf())); + } + self.flags = flags; + return Ok(()) + } + _ => return self.err(format!( + "Unrecognized flag '{}'.", self.cur())), + } + } + } + + // 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 { + 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 { + 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 { + 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 { + match from_str::(s) { + Some(i) => Ok(i), + None => self.err(format!( + "Expected an unsigned integer but got '{}'.", s)), + } + } + + fn char_from_u32(&self, n: u32) -> Result { + match char::from_u32(n) { + Some(c) => Ok(c), + None => self.err(format!( + "Could not decode '{}' to unicode character.", n)), + } + } + + fn pos(&self, c: char) -> Option { + self.chars.iter() + .skip(self.chari).position(|&c2| c2 == c).map(|i| self.chari + i) + } + + fn err(&self, msg: &str) -> Result { + Err(Error { + pos: self.chari, + msg: msg.to_strbuf(), + }) + } + + fn peek(&self, offset: uint) -> Option { + 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) -> StrBuf { + str::from_chars(self.chars.as_slice().slice(start, end)).to_strbuf() + } +} + +// 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 = 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> { + 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')]), +]; diff --git a/src/libregex/parse/unicode.rs b/src/libregex/parse/unicode.rs new file mode 100644 index 00000000000..c263827dab8 --- /dev/null +++ b/src/libregex/parse/unicode.rs @@ -0,0 +1,5537 @@ +// 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 or the MIT license +// , 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') +]; + diff --git a/src/libregex/unicode.rs b/src/libregex/unicode.rs deleted file mode 100644 index c263827dab8..00000000000 --- a/src/libregex/unicode.rs +++ /dev/null @@ -1,5537 +0,0 @@ -// 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 or the MIT license -// , 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') -]; - diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs deleted file mode 100644 index 6df4da89402..00000000000 --- a/src/libsyntax/ext/deriving/generic.rs +++ /dev/null @@ -1,1304 +0,0 @@ -// 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -/*! - -Some code that abstracts away much of the boilerplate of writing -`deriving` instances for traits. Among other things it manages getting -access to the fields of the 4 different sorts of structs and enum -variants, as well as creating the method and impl ast instances. - -Supported features (fairly exhaustive): - -- Methods taking any number of parameters of any type, and returning - any type, other than vectors, bottom and closures. -- Generating `impl`s for types with type parameters and lifetimes - (e.g. `Option`), the parameters are automatically given the - current trait as a bound. (This includes separate type parameters - and lifetimes for methods.) -- Additional bounds on the type parameters, e.g. the `Ord` instance - requires an explicit `Eq` bound at the - moment. (`TraitDef.additional_bounds`) - -Unsupported: FIXME #6257: calling methods on reference fields, -e.g. deriving TotalEq/TotalOrd/Clone don't work on `struct A(&int)`, -because of how the auto-dereferencing happens. - -The most important thing for implementers is the `Substructure` and -`SubstructureFields` objects. The latter groups 5 possibilities of the -arguments: - -- `Struct`, when `Self` is a struct (including tuple structs, e.g - `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. -- `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 -this isn't possible (different variants have different fields), so the -fields are grouped by which argument they come from. There are no -fields with values in the static cases, so these are treated entirely -differently. - -The non-static cases have `Option` in several places associated -with field `expr`s. This represents the name of the field it is -associated with. It is only not `None` when the associated field has -an identifier in the source code. For example, the `x`s in the -following snippet - -```rust -struct A { x : int } - -struct B(int); - -enum C { - C0(int), - C1 { x: int } -} -``` - -The `int`s in `B` and `C0` don't have an identifier, so the -`Option`s would be `None` for them. - -In the static cases, the structure is summarised, either into the just -spans of the fields or a list of spans and the field idents (for tuple -structs and record structs, respectively), or a list of these, for -enums (one for each variant). For empty struct and empty enum -variants, it is represented as a count of 0. - -# Examples - -The following simplified `Eq` is used for in-code examples: - -```rust -trait Eq { - fn eq(&self, other: &Self); -} -impl Eq for int { - fn eq(&self, other: &int) -> bool { - *self == *other - } -} -``` - -Some examples of the values of `SubstructureFields` follow, using the -above `Eq`, `A`, `B` and `C`. - -## Structs - -When generating the `expr` for the `A` impl, the `SubstructureFields` is - -~~~notrust -Struct(~[FieldInfo { - span: - name: Some(), - self_: , - other: ~[, - name: None, - - ~[] - }]) -~~~ - -## Enums - -When generating the `expr` for a call with `self == C0(a)` and `other -== C0(b)`, the SubstructureFields is - -~~~notrust -EnumMatching(0, , - ~[FieldInfo { - span: - name: None, - self_: , - other: ~[] - }]) -~~~ - -For `C1 {x}` and `C1 {x}`, - -~~~notrust -EnumMatching(1, , - ~[FieldInfo { - span: - name: Some(), - self_: , - other: ~[] - }]) -~~~ - -For `C0(a)` and `C1 {x}` , - -~~~notrust -EnumNonMatching(~[(0, , - ~[(, None, )]), - (1, , - ~[(, Some(), - )])]) -~~~ - -(and vice versa, but with the order of the outermost list flipped.) - -## Static - -A static method on the above would result in, - -~~~~notrust -StaticStruct(, Named(~[(, )])) - -StaticStruct(, Unnamed(~[])) - -StaticEnum(, ~[(, , Unnamed(~[])), - (, , - Named(~[(, )]))]) -~~~ - -*/ - -use std::cell::RefCell; - -use ast; -use ast::{P, EnumDef, Expr, Ident, Generics, StructDef}; -use ast_util; -use attr::AttrMetaMethods; -use ext::base::ExtCtxt; -use ext::build::AstBuilder; -use codemap; -use codemap::Span; -use owned_slice::OwnedSlice; -use parse::token::InternedString; - -pub use self::ty::*; -mod ty; - -pub struct TraitDef<'a> { - /// The span for the current #[deriving(Foo)] header. - pub span: Span, - - pub attributes: Vec, - - /// Path of the trait, including any type parameters - pub path: Path<'a>, - - /// Additional bounds required of any type parameters of the type, - /// other than the current trait - pub additional_bounds: Vec>, - - /// Any extra lifetimes and/or bounds, e.g. `D: serialize::Decoder` - pub generics: LifetimeBounds<'a>, - - pub methods: Vec>, -} - - -pub struct MethodDef<'a> { - /// name of the method - pub name: &'a str, - /// List of generics, e.g. `R: rand::Rng` - pub generics: LifetimeBounds<'a>, - - /// Whether there is a self argument (outer Option) i.e. whether - /// this is a static function, and whether it is a pointer (inner - /// Option) - pub explicit_self: Option>>, - - /// Arguments other than the self argument - pub args: Vec>, - - /// Return type - pub ret_ty: Ty<'a>, - - pub attributes: Vec, - - /// 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>, -} - -/// All the data about the data structure/method being derived upon. -pub struct Substructure<'a> { - /// ident of self - pub type_ident: Ident, - /// ident of the method - pub method_ident: Ident, - /// dereferenced access to any Self or Ptr(Self, _) arguments - pub self_args: &'a [@Expr], - /// verbatim access to any other arguments - pub nonself_args: &'a [@Expr], - pub fields: &'a SubstructureFields<'a> -} - -/// Summary of the relevant parts of a struct/enum field. -pub struct FieldInfo { - pub span: Span, - /// None for tuple structs/normal enum variants, Some for normal - /// structs/struct enum variants. - pub name: Option, - /// The expression corresponding to this field of `self` - /// (specifically, a reference to it). - pub self_: @Expr, - /// The expressions corresponding to references to this field in - /// the other Self arguments. - pub other: Vec<@Expr>, -} - -/// Fields for a static method -pub enum StaticFields { - /// Tuple structs/enum variants like this - Unnamed(Vec ), - /// Normal structs/struct variants. - Named(Vec<(Ident, Span)> ) -} - -/// A summary of the possible sets of fields. See above for details -/// and examples -pub enum SubstructureFields<'a> { - Struct(Vec ), - /** - Matching variants of the enum: variant index, ast::Variant, - fields: the field name is only non-`None` in the case of a struct - variant. - */ - EnumMatching(uint, &'a ast::Variant, Vec ), - - /** - 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.) - */ - EnumNonMatching(&'a [(uint, P, Vec<(Span, Option, @Expr)> )]), - - /// A static method where Self is a struct. - StaticStruct(&'a ast::StructDef, StaticFields), - /// A static method where Self is an enum. - StaticEnum(&'a ast::EnumDef, Vec<(Ident, Span, StaticFields)> ) -} - - - -/** -Combine the values of all the fields together. The last argument is -all the fields of all the structures, see above for details. -*/ -pub type CombineSubstructureFunc<'a> = - |&mut ExtCtxt, Span, &Substructure|: 'a -> @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 -*/ -pub type EnumNonMatchFunc<'a> = - |&mut ExtCtxt, - Span, - &[(uint, P, Vec<(Span, Option, @Expr)> )], - &[@Expr]|: 'a - -> @Expr; - -pub fn combine_substructure<'a>(f: CombineSubstructureFunc<'a>) - -> RefCell> { - RefCell::new(f) -} - - -impl<'a> TraitDef<'a> { - pub fn expand(&self, - cx: &mut ExtCtxt, - _mitem: @ast::MetaItem, - item: @ast::Item, - push: |@ast::Item|) { - let newitem = match item.node { - ast::ItemStruct(struct_def, ref generics) => { - self.expand_struct_def(cx, - struct_def, - item.ident, - generics) - } - ast::ItemEnum(ref enum_def, ref generics) => { - self.expand_enum_def(cx, - enum_def, - item.ident, - generics) - } - _ => return - }; - // Keep the lint attributes of the previous item to control how the - // generated implementations are linted - let mut attrs = newitem.attrs.clone(); - attrs.extend(item.attrs.iter().filter(|a| { - match a.name().get() { - "allow" | "warn" | "deny" | "forbid" => true, - _ => false, - } - }).map(|a| a.clone())); - push(@ast::Item { - attrs: attrs, - ..(*newitem).clone() - }) - } - - /** - * - * Given that we are deriving a trait `Tr` for a type `T<'a, ..., - * 'z, A, ..., Z>`, creates an impl like: - * - * ```ignore - * impl<'a, ..., 'z, A:Tr B1 B2, ..., Z: Tr B1 B2> Tr for T { ... } - * ``` - * - * where B1, B2, ... are the bounds given by `bounds_paths`.' - * - */ - fn create_derived_impl(&self, - cx: &mut ExtCtxt, - type_ident: Ident, - generics: &Generics, - methods: Vec<@ast::Method> ) -> @ast::Item { - let trait_path = self.path.to_path(cx, self.span, type_ident, generics); - - let Generics { mut lifetimes, ty_params } = - self.generics.to_generics(cx, self.span, type_ident, generics); - let mut ty_params = ty_params.into_vec(); - - // Copy the lifetimes - lifetimes.extend(generics.lifetimes.iter().map(|l| *l)); - - // Create the type parameters. - ty_params.extend(generics.ty_params.iter().map(|ty_param| { - // I don't think this can be moved out of the loop, since - // a TyParamBound requires an ast id - let mut bounds: Vec<_> = - // extra restrictions on the generics parameters to the type being derived upon - self.additional_bounds.iter().map(|p| { - cx.typarambound(p.to_path(cx, self.span, - type_ident, generics)) - }).collect(); - // require the current trait - bounds.push(cx.typarambound(trait_path.clone())); - - cx.typaram(self.span, - ty_param.ident, - ty_param.sized, - OwnedSlice::from_vec(bounds), - None) - })); - let trait_generics = Generics { - lifetimes: lifetimes, - ty_params: OwnedSlice::from_vec(ty_params) - }; - - // Create the reference to the trait. - let trait_ref = cx.trait_ref(trait_path); - - // Create the type parameters on the `self` path. - let self_ty_params = generics.ty_params.map(|ty_param| { - cx.ty_ident(self.span, ty_param.ident) - }); - - let self_lifetimes = generics.lifetimes.clone(); - - // Create the type of `self`. - let self_type = cx.ty_path( - cx.path_all(self.span, false, vec!( type_ident ), self_lifetimes, - self_ty_params.into_vec()), None); - - let attr = cx.attribute( - self.span, - cx.meta_word(self.span, - InternedString::new("automatically_derived"))); - let opt_trait_ref = Some(trait_ref); - let ident = ast_util::impl_pretty_name(&opt_trait_ref, self_type); - cx.item( - self.span, - ident, - (vec!(attr)).append(self.attributes.as_slice()), - ast::ItemImpl(trait_generics, opt_trait_ref, - self_type, methods)) - } - - fn expand_struct_def(&self, - cx: &mut ExtCtxt, - struct_def: &StructDef, - type_ident: Ident, - generics: &Generics) -> @ast::Item { - let methods = self.methods.iter().map(|method_def| { - let (explicit_self, self_args, nonself_args, tys) = - method_def.split_self_nonself_args( - cx, self, type_ident, generics); - - let body = if method_def.is_static() { - method_def.expand_static_struct_method_body( - cx, - self, - struct_def, - type_ident, - self_args.as_slice(), - nonself_args.as_slice()) - } else { - method_def.expand_struct_method_body(cx, - self, - struct_def, - type_ident, - self_args.as_slice(), - nonself_args.as_slice()) - }; - - method_def.create_method(cx, self, - type_ident, generics, - explicit_self, tys, - body) - }).collect(); - - self.create_derived_impl(cx, type_ident, generics, methods) - } - - fn expand_enum_def(&self, - cx: &mut ExtCtxt, - enum_def: &EnumDef, - type_ident: Ident, - generics: &Generics) -> @ast::Item { - let methods = self.methods.iter().map(|method_def| { - let (explicit_self, self_args, nonself_args, tys) = - method_def.split_self_nonself_args(cx, self, - type_ident, generics); - - let body = if method_def.is_static() { - method_def.expand_static_enum_method_body( - cx, - self, - enum_def, - type_ident, - self_args.as_slice(), - nonself_args.as_slice()) - } else { - method_def.expand_enum_method_body(cx, - self, - enum_def, - type_ident, - self_args.as_slice(), - nonself_args.as_slice()) - }; - - method_def.create_method(cx, self, - type_ident, generics, - explicit_self, tys, - body) - }).collect(); - - self.create_derived_impl(cx, type_ident, generics, methods) - } -} - -impl<'a> MethodDef<'a> { - fn call_substructure_method(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, - type_ident: Ident, - self_args: &[@Expr], - nonself_args: &[@Expr], - fields: &SubstructureFields) - -> @Expr { - let substructure = Substructure { - type_ident: type_ident, - method_ident: cx.ident_of(self.name), - self_args: self_args, - nonself_args: nonself_args, - fields: fields - }; - let mut f = self.combine_substructure.borrow_mut(); - let f: &mut CombineSubstructureFunc = &mut *f; - (*f)(cx, trait_.span, &substructure) - } - - fn get_ret_ty(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, - generics: &Generics, - type_ident: Ident) - -> P { - self.ret_ty.to_ty(cx, trait_.span, type_ident, generics) - } - - fn is_static(&self) -> bool { - self.explicit_self.is_none() - } - - fn split_self_nonself_args(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, - type_ident: Ident, - generics: &Generics) - -> (ast::ExplicitSelf, Vec<@Expr> , Vec<@Expr> , Vec<(Ident, P)> ) { - - let mut self_args = Vec::new(); - let mut nonself_args = Vec::new(); - let mut arg_tys = Vec::new(); - let mut nonstatic = false; - - let ast_explicit_self = match self.explicit_self { - Some(ref self_ptr) => { - let (self_expr, explicit_self) = - ty::get_explicit_self(cx, trait_.span, self_ptr); - - self_args.push(self_expr); - nonstatic = true; - - explicit_self - } - None => codemap::respan(trait_.span, ast::SelfStatic), - }; - - for (i, ty) in self.args.iter().enumerate() { - let ast_ty = ty.to_ty(cx, trait_.span, type_ident, generics); - let ident = cx.ident_of(format!("__arg_{}", i)); - arg_tys.push((ident, ast_ty)); - - let arg_expr = cx.expr_ident(trait_.span, ident); - - match *ty { - // for static methods, just treat any Self - // arguments as a normal arg - Self if nonstatic => { - self_args.push(arg_expr); - } - Ptr(box Self, _) if nonstatic => { - self_args.push(cx.expr_deref(trait_.span, arg_expr)) - } - _ => { - nonself_args.push(arg_expr); - } - } - } - - (ast_explicit_self, self_args, nonself_args, arg_tys) - } - - fn create_method(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, - type_ident: Ident, - generics: &Generics, - explicit_self: ast::ExplicitSelf, - arg_types: Vec<(Ident, P)> , - body: @Expr) -> @ast::Method { - // create the generics that aren't for Self - let fn_generics = self.generics.to_generics(cx, trait_.span, type_ident, generics); - - let self_arg = match explicit_self.node { - ast::SelfStatic => None, - _ => Some(ast::Arg::new_self(trait_.span, ast::MutImmutable)) - }; - let args = { - let args = arg_types.move_iter().map(|(name, ty)| { - cx.arg(trait_.span, name, ty) - }); - self_arg.move_iter().chain(args).collect() - }; - - let ret_type = self.get_ret_ty(cx, trait_, generics, type_ident); - - let method_ident = cx.ident_of(self.name); - let fn_decl = cx.fn_decl(args, ret_type); - let body_block = cx.block_expr(body); - - // Create the method. - @ast::Method { - ident: method_ident, - attrs: self.attributes.clone(), - generics: fn_generics, - explicit_self: explicit_self, - fn_style: ast::NormalFn, - decl: fn_decl, - body: body_block, - id: ast::DUMMY_NODE_ID, - span: trait_.span, - vis: ast::Inherited, - } - } - - /** - ~~~ - #[deriving(Eq)] - struct A { x: int, y: int } - - // equivalent to: - impl Eq for A { - fn eq(&self, __arg_1: &A) -> bool { - match *self { - A {x: ref __self_0_0, y: ref __self_0_1} => { - match *__arg_1 { - A {x: ref __self_1_0, y: ref __self_1_1} => { - __self_0_0.eq(__self_1_0) && __self_0_1.eq(__self_1_1) - } - } - } - } - } - } - ~~~ - */ - fn expand_struct_method_body(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, - struct_def: &StructDef, - type_ident: Ident, - self_args: &[@Expr], - nonself_args: &[@Expr]) - -> @Expr { - - let mut raw_fields = Vec::new(); // ~[[fields of self], - // [fields of next Self arg], [etc]] - let mut patterns = Vec::new(); - for i in range(0u, self_args.len()) { - let (pat, ident_expr) = trait_.create_struct_pattern(cx, type_ident, struct_def, - format!("__self_{}", i), - ast::MutImmutable); - patterns.push(pat); - raw_fields.push(ident_expr); - } - - // transpose raw_fields - let fields = if raw_fields.len() > 0 { - raw_fields.get(0) - .iter() - .enumerate() - .map(|(i, &(span, opt_id, field))| { - let other_fields = raw_fields.tail().iter().map(|l| { - match l.get(i) { - &(_, _, ex) => ex - } - }).collect(); - FieldInfo { - span: span, - name: opt_id, - self_: field, - other: other_fields - } - }).collect() - } else { - cx.span_bug(trait_.span, - "no self arguments to non-static method in generic \ - `deriving`") - }; - - // body of the inner most destructuring match - let mut body = self.call_substructure_method( - cx, - trait_, - type_ident, - self_args, - nonself_args, - &Struct(fields)); - - // make a series of nested matches, to destructure the - // structs. This is actually right-to-left, but it shoudn't - // matter. - for (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) { - body = cx.expr_match(trait_.span, arg_expr, - vec!( cx.arm(trait_.span, vec!(pat), body) )) - } - body - } - - fn expand_static_struct_method_body(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, - struct_def: &StructDef, - type_ident: Ident, - self_args: &[@Expr], - nonself_args: &[@Expr]) - -> @Expr { - let summary = trait_.summarise_struct(cx, struct_def); - - self.call_substructure_method(cx, - trait_, - type_ident, - self_args, nonself_args, - &StaticStruct(struct_def, summary)) - } - - /** - ~~~ - #[deriving(Eq)] - enum A { - A1 - A2(int) - } - - // is equivalent to (with const_nonmatching == false) - - impl Eq 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 expand_enum_method_body(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, - enum_def: &EnumDef, - type_ident: Ident, - self_args: &[@Expr], - nonself_args: &[@Expr]) - -> @Expr { - let mut matches = Vec::new(); - self.build_enum_match(cx, trait_, enum_def, type_ident, - self_args, nonself_args, - None, &mut matches, 0) - } - - - /** - Creates the nested matches for an enum definition recursively, i.e. - - ~~~notrust - match self { - Variant1 => match other { Variant1 => matching, Variant2 => nonmatching, ... }, - Variant2 => match other { Variant1 => nonmatching, Variant2 => matching, ... }, - ... - } - ~~~ - - 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: &[@Expr], - nonself_args: &[@Expr], - matching: Option, - matches_so_far: &mut Vec<(uint, P, - Vec<(Span, Option, @Expr)> )> , - match_count: uint) -> @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 wih 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()) - } - }; - self.call_substructure_method(cx, trait_, type_ident, - self_args, nonself_args, - &substructure) - - } else { // there are still matches to create - let current_match_str = if match_count == 0 { - "__self".to_owned() - } else { - format!("__arg_{}", match_count) - }; - - 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, - 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, - 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); - } - } - - // match foo { arm, arm, arm, ... } - cx.expr_match(trait_.span, self_args[match_count], arms) - } - } - - fn expand_static_enum_method_body(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, - enum_def: &EnumDef, - type_ident: Ident, - self_args: &[@Expr], - nonself_args: &[@Expr]) - -> @Expr { - let summary = enum_def.variants.iter().map(|v| { - let ident = v.node.name; - let summary = match v.node.kind { - ast::TupleVariantKind(ref args) => { - Unnamed(args.iter().map(|va| trait_.set_expn_info(cx, va.ty.span)).collect()) - } - ast::StructVariantKind(struct_def) => { - trait_.summarise_struct(cx, struct_def) - } - }; - (ident, v.span, summary) - }).collect(); - self.call_substructure_method(cx, trait_, type_ident, - self_args, nonself_args, - &StaticEnum(enum_def, summary)) - } -} - -#[deriving(Eq)] // dogfooding! -enum StructType { - Unknown, Record, Tuple -} - -// general helper methods. -impl<'a> TraitDef<'a> { - fn set_expn_info(&self, - cx: &mut ExtCtxt, - mut to_set: Span) -> Span { - let trait_name = match self.path.path.last() { - None => cx.span_bug(self.span, "trait with empty path in generic `deriving`"), - Some(name) => *name - }; - to_set.expn_info = Some(@codemap::ExpnInfo { - call_site: to_set, - callee: codemap::NameAndSpan { - name: format!("deriving({})", trait_name).to_strbuf(), - format: codemap::MacroAttribute, - span: Some(self.span) - } - }); - to_set - } - - fn summarise_struct(&self, - cx: &mut ExtCtxt, - struct_def: &StructDef) -> StaticFields { - let mut named_idents = Vec::new(); - let mut just_spans = Vec::new(); - for field in struct_def.fields.iter(){ - let sp = self.set_expn_info(cx, field.span); - match field.node.kind { - ast::NamedField(ident, _) => named_idents.push((ident, sp)), - ast::UnnamedField(..) => just_spans.push(sp), - } - } - - match (just_spans.is_empty(), named_idents.is_empty()) { - (false, false) => cx.span_bug(self.span, - "a struct with named and unnamed \ - fields in generic `deriving`"), - // named fields - (_, false) => Named(named_idents), - // tuple structs (includes empty structs) - (_, _) => Unnamed(just_spans) - } - } - - fn create_subpatterns(&self, - cx: &mut ExtCtxt, - field_paths: Vec , - mutbl: ast::Mutability) - -> Vec<@ast::Pat> { - field_paths.iter().map(|path| { - cx.pat(path.span, - ast::PatIdent(ast::BindByRef(mutbl), (*path).clone(), None)) - }).collect() - } - - fn create_struct_pattern(&self, - cx: &mut ExtCtxt, - struct_ident: Ident, - struct_def: &StructDef, - prefix: &str, - mutbl: ast::Mutability) - -> (@ast::Pat, Vec<(Span, Option, @Expr)> ) { - if struct_def.fields.is_empty() { - return ( - cx.pat_ident_binding_mode( - self.span, struct_ident, ast::BindByValue(ast::MutImmutable)), - Vec::new()); - } - - let matching_path = cx.path(self.span, vec!( struct_ident )); - - let mut paths = Vec::new(); - let mut ident_expr = Vec::new(); - let mut struct_type = Unknown; - - for (i, struct_field) in struct_def.fields.iter().enumerate() { - let sp = self.set_expn_info(cx, struct_field.span); - let opt_id = match struct_field.node.kind { - ast::NamedField(ident, _) if (struct_type == Unknown || - struct_type == Record) => { - struct_type = Record; - Some(ident) - } - ast::UnnamedField(..) if (struct_type == Unknown || - struct_type == Tuple) => { - struct_type = Tuple; - None - } - _ => { - cx.span_bug(sp, "a struct with named and unnamed fields in `deriving`"); - } - }; - let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i))); - paths.push(path.clone()); - let val = cx.expr( - sp, ast::ExprParen( - cx.expr_deref(sp, cx.expr_path(path)))); - ident_expr.push((sp, opt_id, val)); - } - - let subpats = self.create_subpatterns(cx, paths, mutbl); - - // struct_type is definitely not Unknown, since struct_def.fields - // must be nonempty to reach here - let pattern = if struct_type == Record { - let field_pats = subpats.iter().zip(ident_expr.iter()).map(|(&pat, &(_, id, _))| { - // id is guaranteed to be Some - ast::FieldPat { ident: id.unwrap(), pat: pat } - }).collect(); - cx.pat_struct(self.span, matching_path, field_pats) - } else { - cx.pat_enum(self.span, matching_path, subpats) - }; - - (pattern, ident_expr) - } - - fn create_enum_variant_pattern(&self, - cx: &mut ExtCtxt, - variant: &ast::Variant, - prefix: &str, - mutbl: ast::Mutability) - -> (@ast::Pat, Vec<(Span, Option, @Expr)> ) { - let variant_ident = variant.node.name; - match variant.node.kind { - ast::TupleVariantKind(ref variant_args) => { - if variant_args.is_empty() { - return (cx.pat_ident_binding_mode(variant.span, variant_ident, - ast::BindByValue(ast::MutImmutable)), - Vec::new()); - } - - let matching_path = cx.path_ident(variant.span, variant_ident); - - let mut paths = Vec::new(); - let mut ident_expr = Vec::new(); - for (i, va) in variant_args.iter().enumerate() { - let sp = self.set_expn_info(cx, va.ty.span); - let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i))); - - paths.push(path.clone()); - let val = cx.expr( - sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(path)))); - ident_expr.push((sp, None, val)); - } - - let subpats = self.create_subpatterns(cx, paths, mutbl); - - (cx.pat_enum(variant.span, matching_path, subpats), - ident_expr) - } - ast::StructVariantKind(struct_def) => { - self.create_struct_pattern(cx, variant_ident, struct_def, - prefix, mutbl) - } - } - } -} - -/* helpful premade recipes */ - -/** -Fold the fields. `use_foldl` controls whether this is done -left-to-right (`true`) or right-to-left (`false`). -*/ -pub fn cs_fold(use_foldl: bool, - f: |&mut ExtCtxt, Span, @Expr, @Expr, &[@Expr]| -> @Expr, - base: @Expr, - enum_nonmatch_f: EnumNonMatchFunc, - cx: &mut ExtCtxt, - trait_span: Span, - substructure: &Substructure) - -> @Expr { - match *substructure.fields { - EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => { - if use_foldl { - all_fields.iter().fold(base, |old, field| { - f(cx, - field.span, - old, - field.self_, - field.other.as_slice()) - }) - } else { - all_fields.iter().rev().fold(base, |old, field| { - f(cx, - field.span, - old, - field.self_, - field.other.as_slice()) - }) - } - }, - EnumNonMatching(ref all_enums) => enum_nonmatch_f(cx, trait_span, - *all_enums, - substructure.nonself_args), - StaticEnum(..) | StaticStruct(..) => { - cx.span_bug(trait_span, "static function in `deriving`") - } - } -} - - -/** -Call the method that is being derived on all the fields, and then -process the collected results. i.e. - -~~~ -f(cx, span, ~[self_1.method(__arg_1_1, __arg_2_1), - self_2.method(__arg_1_2, __arg_2_2)]) -~~~ -*/ -#[inline] -pub fn cs_same_method(f: |&mut ExtCtxt, Span, Vec<@Expr> | -> @Expr, - enum_nonmatch_f: EnumNonMatchFunc, - cx: &mut ExtCtxt, - trait_span: Span, - substructure: &Substructure) - -> @Expr { - match *substructure.fields { - EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => { - // call self_n.method(other_1_n, other_2_n, ...) - let called = all_fields.iter().map(|field| { - cx.expr_method_call(field.span, - field.self_, - substructure.method_ident, - field.other.iter() - .map(|e| cx.expr_addr_of(field.span, *e)) - .collect()) - }).collect(); - - f(cx, trait_span, called) - }, - EnumNonMatching(ref all_enums) => enum_nonmatch_f(cx, trait_span, - *all_enums, - substructure.nonself_args), - StaticEnum(..) | StaticStruct(..) => { - cx.span_bug(trait_span, "static function in `deriving`") - } - } -} - -/** -Fold together the results of calling the derived method on all the -fields. `use_foldl` controls whether this is done left-to-right -(`true`) or right-to-left (`false`). -*/ -#[inline] -pub fn cs_same_method_fold(use_foldl: bool, - f: |&mut ExtCtxt, Span, @Expr, @Expr| -> @Expr, - base: @Expr, - enum_nonmatch_f: EnumNonMatchFunc, - cx: &mut ExtCtxt, - trait_span: Span, - substructure: &Substructure) - -> @Expr { - cs_same_method( - |cx, span, vals| { - if use_foldl { - vals.iter().fold(base, |old, &new| { - f(cx, span, old, new) - }) - } else { - vals.iter().rev().fold(base, |old, &new| { - f(cx, span, old, new) - }) - } - }, - enum_nonmatch_f, - cx, trait_span, substructure) -} - -/** -Use a given binop to combine the result of calling the derived method -on all the fields. -*/ -#[inline] -pub fn cs_binop(binop: ast::BinOp, base: @Expr, - enum_nonmatch_f: EnumNonMatchFunc, - cx: &mut ExtCtxt, trait_span: Span, - substructure: &Substructure) -> @Expr { - cs_same_method_fold( - true, // foldl is good enough - |cx, span, old, new| { - cx.expr_binary(span, - binop, - old, new) - - }, - base, - enum_nonmatch_f, - cx, trait_span, substructure) -} - -/// cs_binop with binop == or -#[inline] -pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc, - cx: &mut ExtCtxt, span: Span, - substructure: &Substructure) -> @Expr { - cs_binop(ast::BiOr, cx.expr_bool(span, false), - enum_nonmatch_f, - cx, span, substructure) -} - -/// cs_binop with binop == and -#[inline] -pub fn cs_and(enum_nonmatch_f: EnumNonMatchFunc, - cx: &mut ExtCtxt, span: Span, - substructure: &Substructure) -> @Expr { - cs_binop(ast::BiAnd, cx.expr_bool(span, true), - enum_nonmatch_f, - cx, span, substructure) -} diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs new file mode 100644 index 00000000000..6df4da89402 --- /dev/null +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -0,0 +1,1304 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +/*! + +Some code that abstracts away much of the boilerplate of writing +`deriving` instances for traits. Among other things it manages getting +access to the fields of the 4 different sorts of structs and enum +variants, as well as creating the method and impl ast instances. + +Supported features (fairly exhaustive): + +- Methods taking any number of parameters of any type, and returning + any type, other than vectors, bottom and closures. +- Generating `impl`s for types with type parameters and lifetimes + (e.g. `Option`), the parameters are automatically given the + current trait as a bound. (This includes separate type parameters + and lifetimes for methods.) +- Additional bounds on the type parameters, e.g. the `Ord` instance + requires an explicit `Eq` bound at the + moment. (`TraitDef.additional_bounds`) + +Unsupported: FIXME #6257: calling methods on reference fields, +e.g. deriving TotalEq/TotalOrd/Clone don't work on `struct A(&int)`, +because of how the auto-dereferencing happens. + +The most important thing for implementers is the `Substructure` and +`SubstructureFields` objects. The latter groups 5 possibilities of the +arguments: + +- `Struct`, when `Self` is a struct (including tuple structs, e.g + `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. +- `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 +this isn't possible (different variants have different fields), so the +fields are grouped by which argument they come from. There are no +fields with values in the static cases, so these are treated entirely +differently. + +The non-static cases have `Option` in several places associated +with field `expr`s. This represents the name of the field it is +associated with. It is only not `None` when the associated field has +an identifier in the source code. For example, the `x`s in the +following snippet + +```rust +struct A { x : int } + +struct B(int); + +enum C { + C0(int), + C1 { x: int } +} +``` + +The `int`s in `B` and `C0` don't have an identifier, so the +`Option`s would be `None` for them. + +In the static cases, the structure is summarised, either into the just +spans of the fields or a list of spans and the field idents (for tuple +structs and record structs, respectively), or a list of these, for +enums (one for each variant). For empty struct and empty enum +variants, it is represented as a count of 0. + +# Examples + +The following simplified `Eq` is used for in-code examples: + +```rust +trait Eq { + fn eq(&self, other: &Self); +} +impl Eq for int { + fn eq(&self, other: &int) -> bool { + *self == *other + } +} +``` + +Some examples of the values of `SubstructureFields` follow, using the +above `Eq`, `A`, `B` and `C`. + +## Structs + +When generating the `expr` for the `A` impl, the `SubstructureFields` is + +~~~notrust +Struct(~[FieldInfo { + span: + name: Some(), + self_: , + other: ~[, + name: None, + + ~[] + }]) +~~~ + +## Enums + +When generating the `expr` for a call with `self == C0(a)` and `other +== C0(b)`, the SubstructureFields is + +~~~notrust +EnumMatching(0, , + ~[FieldInfo { + span: + name: None, + self_: , + other: ~[] + }]) +~~~ + +For `C1 {x}` and `C1 {x}`, + +~~~notrust +EnumMatching(1, , + ~[FieldInfo { + span: + name: Some(), + self_: , + other: ~[] + }]) +~~~ + +For `C0(a)` and `C1 {x}` , + +~~~notrust +EnumNonMatching(~[(0, , + ~[(, None, )]), + (1, , + ~[(, Some(), + )])]) +~~~ + +(and vice versa, but with the order of the outermost list flipped.) + +## Static + +A static method on the above would result in, + +~~~~notrust +StaticStruct(, Named(~[(, )])) + +StaticStruct(, Unnamed(~[])) + +StaticEnum(, ~[(, , Unnamed(~[])), + (, , + Named(~[(, )]))]) +~~~ + +*/ + +use std::cell::RefCell; + +use ast; +use ast::{P, EnumDef, Expr, Ident, Generics, StructDef}; +use ast_util; +use attr::AttrMetaMethods; +use ext::base::ExtCtxt; +use ext::build::AstBuilder; +use codemap; +use codemap::Span; +use owned_slice::OwnedSlice; +use parse::token::InternedString; + +pub use self::ty::*; +mod ty; + +pub struct TraitDef<'a> { + /// The span for the current #[deriving(Foo)] header. + pub span: Span, + + pub attributes: Vec, + + /// Path of the trait, including any type parameters + pub path: Path<'a>, + + /// Additional bounds required of any type parameters of the type, + /// other than the current trait + pub additional_bounds: Vec>, + + /// Any extra lifetimes and/or bounds, e.g. `D: serialize::Decoder` + pub generics: LifetimeBounds<'a>, + + pub methods: Vec>, +} + + +pub struct MethodDef<'a> { + /// name of the method + pub name: &'a str, + /// List of generics, e.g. `R: rand::Rng` + pub generics: LifetimeBounds<'a>, + + /// Whether there is a self argument (outer Option) i.e. whether + /// this is a static function, and whether it is a pointer (inner + /// Option) + pub explicit_self: Option>>, + + /// Arguments other than the self argument + pub args: Vec>, + + /// Return type + pub ret_ty: Ty<'a>, + + pub attributes: Vec, + + /// 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>, +} + +/// All the data about the data structure/method being derived upon. +pub struct Substructure<'a> { + /// ident of self + pub type_ident: Ident, + /// ident of the method + pub method_ident: Ident, + /// dereferenced access to any Self or Ptr(Self, _) arguments + pub self_args: &'a [@Expr], + /// verbatim access to any other arguments + pub nonself_args: &'a [@Expr], + pub fields: &'a SubstructureFields<'a> +} + +/// Summary of the relevant parts of a struct/enum field. +pub struct FieldInfo { + pub span: Span, + /// None for tuple structs/normal enum variants, Some for normal + /// structs/struct enum variants. + pub name: Option, + /// The expression corresponding to this field of `self` + /// (specifically, a reference to it). + pub self_: @Expr, + /// The expressions corresponding to references to this field in + /// the other Self arguments. + pub other: Vec<@Expr>, +} + +/// Fields for a static method +pub enum StaticFields { + /// Tuple structs/enum variants like this + Unnamed(Vec ), + /// Normal structs/struct variants. + Named(Vec<(Ident, Span)> ) +} + +/// A summary of the possible sets of fields. See above for details +/// and examples +pub enum SubstructureFields<'a> { + Struct(Vec ), + /** + Matching variants of the enum: variant index, ast::Variant, + fields: the field name is only non-`None` in the case of a struct + variant. + */ + EnumMatching(uint, &'a ast::Variant, Vec ), + + /** + 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.) + */ + EnumNonMatching(&'a [(uint, P, Vec<(Span, Option, @Expr)> )]), + + /// A static method where Self is a struct. + StaticStruct(&'a ast::StructDef, StaticFields), + /// A static method where Self is an enum. + StaticEnum(&'a ast::EnumDef, Vec<(Ident, Span, StaticFields)> ) +} + + + +/** +Combine the values of all the fields together. The last argument is +all the fields of all the structures, see above for details. +*/ +pub type CombineSubstructureFunc<'a> = + |&mut ExtCtxt, Span, &Substructure|: 'a -> @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 +*/ +pub type EnumNonMatchFunc<'a> = + |&mut ExtCtxt, + Span, + &[(uint, P, Vec<(Span, Option, @Expr)> )], + &[@Expr]|: 'a + -> @Expr; + +pub fn combine_substructure<'a>(f: CombineSubstructureFunc<'a>) + -> RefCell> { + RefCell::new(f) +} + + +impl<'a> TraitDef<'a> { + pub fn expand(&self, + cx: &mut ExtCtxt, + _mitem: @ast::MetaItem, + item: @ast::Item, + push: |@ast::Item|) { + let newitem = match item.node { + ast::ItemStruct(struct_def, ref generics) => { + self.expand_struct_def(cx, + struct_def, + item.ident, + generics) + } + ast::ItemEnum(ref enum_def, ref generics) => { + self.expand_enum_def(cx, + enum_def, + item.ident, + generics) + } + _ => return + }; + // Keep the lint attributes of the previous item to control how the + // generated implementations are linted + let mut attrs = newitem.attrs.clone(); + attrs.extend(item.attrs.iter().filter(|a| { + match a.name().get() { + "allow" | "warn" | "deny" | "forbid" => true, + _ => false, + } + }).map(|a| a.clone())); + push(@ast::Item { + attrs: attrs, + ..(*newitem).clone() + }) + } + + /** + * + * Given that we are deriving a trait `Tr` for a type `T<'a, ..., + * 'z, A, ..., Z>`, creates an impl like: + * + * ```ignore + * impl<'a, ..., 'z, A:Tr B1 B2, ..., Z: Tr B1 B2> Tr for T { ... } + * ``` + * + * where B1, B2, ... are the bounds given by `bounds_paths`.' + * + */ + fn create_derived_impl(&self, + cx: &mut ExtCtxt, + type_ident: Ident, + generics: &Generics, + methods: Vec<@ast::Method> ) -> @ast::Item { + let trait_path = self.path.to_path(cx, self.span, type_ident, generics); + + let Generics { mut lifetimes, ty_params } = + self.generics.to_generics(cx, self.span, type_ident, generics); + let mut ty_params = ty_params.into_vec(); + + // Copy the lifetimes + lifetimes.extend(generics.lifetimes.iter().map(|l| *l)); + + // Create the type parameters. + ty_params.extend(generics.ty_params.iter().map(|ty_param| { + // I don't think this can be moved out of the loop, since + // a TyParamBound requires an ast id + let mut bounds: Vec<_> = + // extra restrictions on the generics parameters to the type being derived upon + self.additional_bounds.iter().map(|p| { + cx.typarambound(p.to_path(cx, self.span, + type_ident, generics)) + }).collect(); + // require the current trait + bounds.push(cx.typarambound(trait_path.clone())); + + cx.typaram(self.span, + ty_param.ident, + ty_param.sized, + OwnedSlice::from_vec(bounds), + None) + })); + let trait_generics = Generics { + lifetimes: lifetimes, + ty_params: OwnedSlice::from_vec(ty_params) + }; + + // Create the reference to the trait. + let trait_ref = cx.trait_ref(trait_path); + + // Create the type parameters on the `self` path. + let self_ty_params = generics.ty_params.map(|ty_param| { + cx.ty_ident(self.span, ty_param.ident) + }); + + let self_lifetimes = generics.lifetimes.clone(); + + // Create the type of `self`. + let self_type = cx.ty_path( + cx.path_all(self.span, false, vec!( type_ident ), self_lifetimes, + self_ty_params.into_vec()), None); + + let attr = cx.attribute( + self.span, + cx.meta_word(self.span, + InternedString::new("automatically_derived"))); + let opt_trait_ref = Some(trait_ref); + let ident = ast_util::impl_pretty_name(&opt_trait_ref, self_type); + cx.item( + self.span, + ident, + (vec!(attr)).append(self.attributes.as_slice()), + ast::ItemImpl(trait_generics, opt_trait_ref, + self_type, methods)) + } + + fn expand_struct_def(&self, + cx: &mut ExtCtxt, + struct_def: &StructDef, + type_ident: Ident, + generics: &Generics) -> @ast::Item { + let methods = self.methods.iter().map(|method_def| { + let (explicit_self, self_args, nonself_args, tys) = + method_def.split_self_nonself_args( + cx, self, type_ident, generics); + + let body = if method_def.is_static() { + method_def.expand_static_struct_method_body( + cx, + self, + struct_def, + type_ident, + self_args.as_slice(), + nonself_args.as_slice()) + } else { + method_def.expand_struct_method_body(cx, + self, + struct_def, + type_ident, + self_args.as_slice(), + nonself_args.as_slice()) + }; + + method_def.create_method(cx, self, + type_ident, generics, + explicit_self, tys, + body) + }).collect(); + + self.create_derived_impl(cx, type_ident, generics, methods) + } + + fn expand_enum_def(&self, + cx: &mut ExtCtxt, + enum_def: &EnumDef, + type_ident: Ident, + generics: &Generics) -> @ast::Item { + let methods = self.methods.iter().map(|method_def| { + let (explicit_self, self_args, nonself_args, tys) = + method_def.split_self_nonself_args(cx, self, + type_ident, generics); + + let body = if method_def.is_static() { + method_def.expand_static_enum_method_body( + cx, + self, + enum_def, + type_ident, + self_args.as_slice(), + nonself_args.as_slice()) + } else { + method_def.expand_enum_method_body(cx, + self, + enum_def, + type_ident, + self_args.as_slice(), + nonself_args.as_slice()) + }; + + method_def.create_method(cx, self, + type_ident, generics, + explicit_self, tys, + body) + }).collect(); + + self.create_derived_impl(cx, type_ident, generics, methods) + } +} + +impl<'a> MethodDef<'a> { + fn call_substructure_method(&self, + cx: &mut ExtCtxt, + trait_: &TraitDef, + type_ident: Ident, + self_args: &[@Expr], + nonself_args: &[@Expr], + fields: &SubstructureFields) + -> @Expr { + let substructure = Substructure { + type_ident: type_ident, + method_ident: cx.ident_of(self.name), + self_args: self_args, + nonself_args: nonself_args, + fields: fields + }; + let mut f = self.combine_substructure.borrow_mut(); + let f: &mut CombineSubstructureFunc = &mut *f; + (*f)(cx, trait_.span, &substructure) + } + + fn get_ret_ty(&self, + cx: &mut ExtCtxt, + trait_: &TraitDef, + generics: &Generics, + type_ident: Ident) + -> P { + self.ret_ty.to_ty(cx, trait_.span, type_ident, generics) + } + + fn is_static(&self) -> bool { + self.explicit_self.is_none() + } + + fn split_self_nonself_args(&self, + cx: &mut ExtCtxt, + trait_: &TraitDef, + type_ident: Ident, + generics: &Generics) + -> (ast::ExplicitSelf, Vec<@Expr> , Vec<@Expr> , Vec<(Ident, P)> ) { + + let mut self_args = Vec::new(); + let mut nonself_args = Vec::new(); + let mut arg_tys = Vec::new(); + let mut nonstatic = false; + + let ast_explicit_self = match self.explicit_self { + Some(ref self_ptr) => { + let (self_expr, explicit_self) = + ty::get_explicit_self(cx, trait_.span, self_ptr); + + self_args.push(self_expr); + nonstatic = true; + + explicit_self + } + None => codemap::respan(trait_.span, ast::SelfStatic), + }; + + for (i, ty) in self.args.iter().enumerate() { + let ast_ty = ty.to_ty(cx, trait_.span, type_ident, generics); + let ident = cx.ident_of(format!("__arg_{}", i)); + arg_tys.push((ident, ast_ty)); + + let arg_expr = cx.expr_ident(trait_.span, ident); + + match *ty { + // for static methods, just treat any Self + // arguments as a normal arg + Self if nonstatic => { + self_args.push(arg_expr); + } + Ptr(box Self, _) if nonstatic => { + self_args.push(cx.expr_deref(trait_.span, arg_expr)) + } + _ => { + nonself_args.push(arg_expr); + } + } + } + + (ast_explicit_self, self_args, nonself_args, arg_tys) + } + + fn create_method(&self, + cx: &mut ExtCtxt, + trait_: &TraitDef, + type_ident: Ident, + generics: &Generics, + explicit_self: ast::ExplicitSelf, + arg_types: Vec<(Ident, P)> , + body: @Expr) -> @ast::Method { + // create the generics that aren't for Self + let fn_generics = self.generics.to_generics(cx, trait_.span, type_ident, generics); + + let self_arg = match explicit_self.node { + ast::SelfStatic => None, + _ => Some(ast::Arg::new_self(trait_.span, ast::MutImmutable)) + }; + let args = { + let args = arg_types.move_iter().map(|(name, ty)| { + cx.arg(trait_.span, name, ty) + }); + self_arg.move_iter().chain(args).collect() + }; + + let ret_type = self.get_ret_ty(cx, trait_, generics, type_ident); + + let method_ident = cx.ident_of(self.name); + let fn_decl = cx.fn_decl(args, ret_type); + let body_block = cx.block_expr(body); + + // Create the method. + @ast::Method { + ident: method_ident, + attrs: self.attributes.clone(), + generics: fn_generics, + explicit_self: explicit_self, + fn_style: ast::NormalFn, + decl: fn_decl, + body: body_block, + id: ast::DUMMY_NODE_ID, + span: trait_.span, + vis: ast::Inherited, + } + } + + /** + ~~~ + #[deriving(Eq)] + struct A { x: int, y: int } + + // equivalent to: + impl Eq for A { + fn eq(&self, __arg_1: &A) -> bool { + match *self { + A {x: ref __self_0_0, y: ref __self_0_1} => { + match *__arg_1 { + A {x: ref __self_1_0, y: ref __self_1_1} => { + __self_0_0.eq(__self_1_0) && __self_0_1.eq(__self_1_1) + } + } + } + } + } + } + ~~~ + */ + fn expand_struct_method_body(&self, + cx: &mut ExtCtxt, + trait_: &TraitDef, + struct_def: &StructDef, + type_ident: Ident, + self_args: &[@Expr], + nonself_args: &[@Expr]) + -> @Expr { + + let mut raw_fields = Vec::new(); // ~[[fields of self], + // [fields of next Self arg], [etc]] + let mut patterns = Vec::new(); + for i in range(0u, self_args.len()) { + let (pat, ident_expr) = trait_.create_struct_pattern(cx, type_ident, struct_def, + format!("__self_{}", i), + ast::MutImmutable); + patterns.push(pat); + raw_fields.push(ident_expr); + } + + // transpose raw_fields + let fields = if raw_fields.len() > 0 { + raw_fields.get(0) + .iter() + .enumerate() + .map(|(i, &(span, opt_id, field))| { + let other_fields = raw_fields.tail().iter().map(|l| { + match l.get(i) { + &(_, _, ex) => ex + } + }).collect(); + FieldInfo { + span: span, + name: opt_id, + self_: field, + other: other_fields + } + }).collect() + } else { + cx.span_bug(trait_.span, + "no self arguments to non-static method in generic \ + `deriving`") + }; + + // body of the inner most destructuring match + let mut body = self.call_substructure_method( + cx, + trait_, + type_ident, + self_args, + nonself_args, + &Struct(fields)); + + // make a series of nested matches, to destructure the + // structs. This is actually right-to-left, but it shoudn't + // matter. + for (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) { + body = cx.expr_match(trait_.span, arg_expr, + vec!( cx.arm(trait_.span, vec!(pat), body) )) + } + body + } + + fn expand_static_struct_method_body(&self, + cx: &mut ExtCtxt, + trait_: &TraitDef, + struct_def: &StructDef, + type_ident: Ident, + self_args: &[@Expr], + nonself_args: &[@Expr]) + -> @Expr { + let summary = trait_.summarise_struct(cx, struct_def); + + self.call_substructure_method(cx, + trait_, + type_ident, + self_args, nonself_args, + &StaticStruct(struct_def, summary)) + } + + /** + ~~~ + #[deriving(Eq)] + enum A { + A1 + A2(int) + } + + // is equivalent to (with const_nonmatching == false) + + impl Eq 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 expand_enum_method_body(&self, + cx: &mut ExtCtxt, + trait_: &TraitDef, + enum_def: &EnumDef, + type_ident: Ident, + self_args: &[@Expr], + nonself_args: &[@Expr]) + -> @Expr { + let mut matches = Vec::new(); + self.build_enum_match(cx, trait_, enum_def, type_ident, + self_args, nonself_args, + None, &mut matches, 0) + } + + + /** + Creates the nested matches for an enum definition recursively, i.e. + + ~~~notrust + match self { + Variant1 => match other { Variant1 => matching, Variant2 => nonmatching, ... }, + Variant2 => match other { Variant1 => nonmatching, Variant2 => matching, ... }, + ... + } + ~~~ + + 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: &[@Expr], + nonself_args: &[@Expr], + matching: Option, + matches_so_far: &mut Vec<(uint, P, + Vec<(Span, Option, @Expr)> )> , + match_count: uint) -> @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 wih 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()) + } + }; + self.call_substructure_method(cx, trait_, type_ident, + self_args, nonself_args, + &substructure) + + } else { // there are still matches to create + let current_match_str = if match_count == 0 { + "__self".to_owned() + } else { + format!("__arg_{}", match_count) + }; + + 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, + 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, + 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); + } + } + + // match foo { arm, arm, arm, ... } + cx.expr_match(trait_.span, self_args[match_count], arms) + } + } + + fn expand_static_enum_method_body(&self, + cx: &mut ExtCtxt, + trait_: &TraitDef, + enum_def: &EnumDef, + type_ident: Ident, + self_args: &[@Expr], + nonself_args: &[@Expr]) + -> @Expr { + let summary = enum_def.variants.iter().map(|v| { + let ident = v.node.name; + let summary = match v.node.kind { + ast::TupleVariantKind(ref args) => { + Unnamed(args.iter().map(|va| trait_.set_expn_info(cx, va.ty.span)).collect()) + } + ast::StructVariantKind(struct_def) => { + trait_.summarise_struct(cx, struct_def) + } + }; + (ident, v.span, summary) + }).collect(); + self.call_substructure_method(cx, trait_, type_ident, + self_args, nonself_args, + &StaticEnum(enum_def, summary)) + } +} + +#[deriving(Eq)] // dogfooding! +enum StructType { + Unknown, Record, Tuple +} + +// general helper methods. +impl<'a> TraitDef<'a> { + fn set_expn_info(&self, + cx: &mut ExtCtxt, + mut to_set: Span) -> Span { + let trait_name = match self.path.path.last() { + None => cx.span_bug(self.span, "trait with empty path in generic `deriving`"), + Some(name) => *name + }; + to_set.expn_info = Some(@codemap::ExpnInfo { + call_site: to_set, + callee: codemap::NameAndSpan { + name: format!("deriving({})", trait_name).to_strbuf(), + format: codemap::MacroAttribute, + span: Some(self.span) + } + }); + to_set + } + + fn summarise_struct(&self, + cx: &mut ExtCtxt, + struct_def: &StructDef) -> StaticFields { + let mut named_idents = Vec::new(); + let mut just_spans = Vec::new(); + for field in struct_def.fields.iter(){ + let sp = self.set_expn_info(cx, field.span); + match field.node.kind { + ast::NamedField(ident, _) => named_idents.push((ident, sp)), + ast::UnnamedField(..) => just_spans.push(sp), + } + } + + match (just_spans.is_empty(), named_idents.is_empty()) { + (false, false) => cx.span_bug(self.span, + "a struct with named and unnamed \ + fields in generic `deriving`"), + // named fields + (_, false) => Named(named_idents), + // tuple structs (includes empty structs) + (_, _) => Unnamed(just_spans) + } + } + + fn create_subpatterns(&self, + cx: &mut ExtCtxt, + field_paths: Vec , + mutbl: ast::Mutability) + -> Vec<@ast::Pat> { + field_paths.iter().map(|path| { + cx.pat(path.span, + ast::PatIdent(ast::BindByRef(mutbl), (*path).clone(), None)) + }).collect() + } + + fn create_struct_pattern(&self, + cx: &mut ExtCtxt, + struct_ident: Ident, + struct_def: &StructDef, + prefix: &str, + mutbl: ast::Mutability) + -> (@ast::Pat, Vec<(Span, Option, @Expr)> ) { + if struct_def.fields.is_empty() { + return ( + cx.pat_ident_binding_mode( + self.span, struct_ident, ast::BindByValue(ast::MutImmutable)), + Vec::new()); + } + + let matching_path = cx.path(self.span, vec!( struct_ident )); + + let mut paths = Vec::new(); + let mut ident_expr = Vec::new(); + let mut struct_type = Unknown; + + for (i, struct_field) in struct_def.fields.iter().enumerate() { + let sp = self.set_expn_info(cx, struct_field.span); + let opt_id = match struct_field.node.kind { + ast::NamedField(ident, _) if (struct_type == Unknown || + struct_type == Record) => { + struct_type = Record; + Some(ident) + } + ast::UnnamedField(..) if (struct_type == Unknown || + struct_type == Tuple) => { + struct_type = Tuple; + None + } + _ => { + cx.span_bug(sp, "a struct with named and unnamed fields in `deriving`"); + } + }; + let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i))); + paths.push(path.clone()); + let val = cx.expr( + sp, ast::ExprParen( + cx.expr_deref(sp, cx.expr_path(path)))); + ident_expr.push((sp, opt_id, val)); + } + + let subpats = self.create_subpatterns(cx, paths, mutbl); + + // struct_type is definitely not Unknown, since struct_def.fields + // must be nonempty to reach here + let pattern = if struct_type == Record { + let field_pats = subpats.iter().zip(ident_expr.iter()).map(|(&pat, &(_, id, _))| { + // id is guaranteed to be Some + ast::FieldPat { ident: id.unwrap(), pat: pat } + }).collect(); + cx.pat_struct(self.span, matching_path, field_pats) + } else { + cx.pat_enum(self.span, matching_path, subpats) + }; + + (pattern, ident_expr) + } + + fn create_enum_variant_pattern(&self, + cx: &mut ExtCtxt, + variant: &ast::Variant, + prefix: &str, + mutbl: ast::Mutability) + -> (@ast::Pat, Vec<(Span, Option, @Expr)> ) { + let variant_ident = variant.node.name; + match variant.node.kind { + ast::TupleVariantKind(ref variant_args) => { + if variant_args.is_empty() { + return (cx.pat_ident_binding_mode(variant.span, variant_ident, + ast::BindByValue(ast::MutImmutable)), + Vec::new()); + } + + let matching_path = cx.path_ident(variant.span, variant_ident); + + let mut paths = Vec::new(); + let mut ident_expr = Vec::new(); + for (i, va) in variant_args.iter().enumerate() { + let sp = self.set_expn_info(cx, va.ty.span); + let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i))); + + paths.push(path.clone()); + let val = cx.expr( + sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(path)))); + ident_expr.push((sp, None, val)); + } + + let subpats = self.create_subpatterns(cx, paths, mutbl); + + (cx.pat_enum(variant.span, matching_path, subpats), + ident_expr) + } + ast::StructVariantKind(struct_def) => { + self.create_struct_pattern(cx, variant_ident, struct_def, + prefix, mutbl) + } + } + } +} + +/* helpful premade recipes */ + +/** +Fold the fields. `use_foldl` controls whether this is done +left-to-right (`true`) or right-to-left (`false`). +*/ +pub fn cs_fold(use_foldl: bool, + f: |&mut ExtCtxt, Span, @Expr, @Expr, &[@Expr]| -> @Expr, + base: @Expr, + enum_nonmatch_f: EnumNonMatchFunc, + cx: &mut ExtCtxt, + trait_span: Span, + substructure: &Substructure) + -> @Expr { + match *substructure.fields { + EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => { + if use_foldl { + all_fields.iter().fold(base, |old, field| { + f(cx, + field.span, + old, + field.self_, + field.other.as_slice()) + }) + } else { + all_fields.iter().rev().fold(base, |old, field| { + f(cx, + field.span, + old, + field.self_, + field.other.as_slice()) + }) + } + }, + EnumNonMatching(ref all_enums) => enum_nonmatch_f(cx, trait_span, + *all_enums, + substructure.nonself_args), + StaticEnum(..) | StaticStruct(..) => { + cx.span_bug(trait_span, "static function in `deriving`") + } + } +} + + +/** +Call the method that is being derived on all the fields, and then +process the collected results. i.e. + +~~~ +f(cx, span, ~[self_1.method(__arg_1_1, __arg_2_1), + self_2.method(__arg_1_2, __arg_2_2)]) +~~~ +*/ +#[inline] +pub fn cs_same_method(f: |&mut ExtCtxt, Span, Vec<@Expr> | -> @Expr, + enum_nonmatch_f: EnumNonMatchFunc, + cx: &mut ExtCtxt, + trait_span: Span, + substructure: &Substructure) + -> @Expr { + match *substructure.fields { + EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => { + // call self_n.method(other_1_n, other_2_n, ...) + let called = all_fields.iter().map(|field| { + cx.expr_method_call(field.span, + field.self_, + substructure.method_ident, + field.other.iter() + .map(|e| cx.expr_addr_of(field.span, *e)) + .collect()) + }).collect(); + + f(cx, trait_span, called) + }, + EnumNonMatching(ref all_enums) => enum_nonmatch_f(cx, trait_span, + *all_enums, + substructure.nonself_args), + StaticEnum(..) | StaticStruct(..) => { + cx.span_bug(trait_span, "static function in `deriving`") + } + } +} + +/** +Fold together the results of calling the derived method on all the +fields. `use_foldl` controls whether this is done left-to-right +(`true`) or right-to-left (`false`). +*/ +#[inline] +pub fn cs_same_method_fold(use_foldl: bool, + f: |&mut ExtCtxt, Span, @Expr, @Expr| -> @Expr, + base: @Expr, + enum_nonmatch_f: EnumNonMatchFunc, + cx: &mut ExtCtxt, + trait_span: Span, + substructure: &Substructure) + -> @Expr { + cs_same_method( + |cx, span, vals| { + if use_foldl { + vals.iter().fold(base, |old, &new| { + f(cx, span, old, new) + }) + } else { + vals.iter().rev().fold(base, |old, &new| { + f(cx, span, old, new) + }) + } + }, + enum_nonmatch_f, + cx, trait_span, substructure) +} + +/** +Use a given binop to combine the result of calling the derived method +on all the fields. +*/ +#[inline] +pub fn cs_binop(binop: ast::BinOp, base: @Expr, + enum_nonmatch_f: EnumNonMatchFunc, + cx: &mut ExtCtxt, trait_span: Span, + substructure: &Substructure) -> @Expr { + cs_same_method_fold( + true, // foldl is good enough + |cx, span, old, new| { + cx.expr_binary(span, + binop, + old, new) + + }, + base, + enum_nonmatch_f, + cx, trait_span, substructure) +} + +/// cs_binop with binop == or +#[inline] +pub fn cs_or(enum_nonmatch_f: EnumNonMatchFunc, + cx: &mut ExtCtxt, span: Span, + substructure: &Substructure) -> @Expr { + cs_binop(ast::BiOr, cx.expr_bool(span, false), + enum_nonmatch_f, + cx, span, substructure) +} + +/// cs_binop with binop == and +#[inline] +pub fn cs_and(enum_nonmatch_f: EnumNonMatchFunc, + cx: &mut ExtCtxt, span: Span, + substructure: &Substructure) -> @Expr { + cs_binop(ast::BiAnd, cx.expr_bool(span, true), + enum_nonmatch_f, + cx, span, substructure) +} diff --git a/src/libsyntax/ext/deriving/generic/ty.rs b/src/libsyntax/ext/deriving/generic/ty.rs new file mode 100644 index 00000000000..602245b4c47 --- /dev/null +++ b/src/libsyntax/ext/deriving/generic/ty.rs @@ -0,0 +1,267 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +/*! +A mini version of ast::Ty, which is easier to use, and features an +explicit `Self` type to use when specifying impls to be derived. +*/ + +use ast; +use ast::{P,Expr,Generics,Ident}; +use ext::base::ExtCtxt; +use ext::build::AstBuilder; +use codemap::{Span,respan}; +use owned_slice::OwnedSlice; + + +/// The types of pointers +pub enum PtrTy<'a> { + Send, // ~ + Borrowed(Option<&'a str>, ast::Mutability), // &['lifetime] [mut] +} + +/// A path, e.g. `::std::option::Option::` (global). Has support +/// for type parameters and a lifetime. +pub struct Path<'a> { + pub path: Vec<&'a str> , + pub lifetime: Option<&'a str>, + pub params: Vec>>, + pub global: bool, +} + +impl<'a> Path<'a> { + pub fn new<'r>(path: Vec<&'r str> ) -> Path<'r> { + Path::new_(path, None, Vec::new(), true) + } + pub fn new_local<'r>(path: &'r str) -> Path<'r> { + Path::new_(vec!( path ), None, Vec::new(), false) + } + pub fn new_<'r>(path: Vec<&'r str> , + lifetime: Option<&'r str>, + params: Vec>>, + global: bool) + -> Path<'r> { + Path { + path: path, + lifetime: lifetime, + params: params, + global: global + } + } + + pub fn to_ty(&self, + cx: &ExtCtxt, + span: Span, + self_ty: Ident, + self_generics: &Generics) + -> P { + cx.ty_path(self.to_path(cx, span, self_ty, self_generics), None) + } + pub fn to_path(&self, + cx: &ExtCtxt, + span: Span, + self_ty: Ident, + self_generics: &Generics) + -> ast::Path { + let idents = self.path.iter().map(|s| cx.ident_of(*s)).collect(); + let lt = mk_lifetimes(cx, span, &self.lifetime); + let tys = self.params.iter().map(|t| t.to_ty(cx, span, self_ty, self_generics)).collect(); + + cx.path_all(span, self.global, idents, lt, tys) + } +} + +/// A type. Supports pointers (except for *), Self, and literals +pub enum Ty<'a> { + Self, + // &/Box/@ Ty + Ptr(Box>, PtrTy<'a>), + // mod::mod::Type<[lifetime], [Params...]>, including a plain type + // parameter, and things like `int` + Literal(Path<'a>), + // includes nil + Tuple(Vec> ) +} + +pub fn borrowed_ptrty<'r>() -> PtrTy<'r> { + Borrowed(None, ast::MutImmutable) +} +pub fn borrowed<'r>(ty: Box>) -> Ty<'r> { + Ptr(ty, borrowed_ptrty()) +} + +pub fn borrowed_explicit_self<'r>() -> Option>> { + Some(Some(borrowed_ptrty())) +} + +pub fn borrowed_self<'r>() -> Ty<'r> { + borrowed(box Self) +} + +pub fn nil_ty() -> Ty<'static> { + Tuple(Vec::new()) +} + +fn mk_lifetime(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Option { + match *lt { + Some(ref s) => Some(cx.lifetime(span, cx.ident_of(*s).name)), + None => None + } +} + +fn mk_lifetimes(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Vec { + match *lt { + Some(ref s) => vec!(cx.lifetime(span, cx.ident_of(*s).name)), + None => vec!() + } +} + +impl<'a> Ty<'a> { + pub fn to_ty(&self, + cx: &ExtCtxt, + span: Span, + self_ty: Ident, + self_generics: &Generics) + -> P { + match *self { + Ptr(ref ty, ref ptr) => { + let raw_ty = ty.to_ty(cx, span, self_ty, self_generics); + match *ptr { + Send => { + cx.ty_uniq(span, raw_ty) + } + Borrowed(ref lt, mutbl) => { + let lt = mk_lifetime(cx, span, lt); + cx.ty_rptr(span, raw_ty, lt, mutbl) + } + } + } + Literal(ref p) => { p.to_ty(cx, span, self_ty, self_generics) } + Self => { + cx.ty_path(self.to_path(cx, span, self_ty, self_generics), None) + } + Tuple(ref fields) => { + let ty = if fields.is_empty() { + ast::TyNil + } else { + ast::TyTup(fields.iter() + .map(|f| f.to_ty(cx, span, self_ty, self_generics)) + .collect()) + }; + + cx.ty(span, ty) + } + } + } + + pub fn to_path(&self, + cx: &ExtCtxt, + span: Span, + self_ty: Ident, + self_generics: &Generics) + -> ast::Path { + match *self { + Self => { + let self_params = self_generics.ty_params.map(|ty_param| { + cx.ty_ident(span, ty_param.ident) + }); + let lifetimes = self_generics.lifetimes.clone(); + + cx.path_all(span, false, vec!(self_ty), lifetimes, + self_params.into_vec()) + } + Literal(ref p) => { + p.to_path(cx, span, self_ty, self_generics) + } + Ptr(..) => { cx.span_bug(span, "pointer in a path in generic `deriving`") } + Tuple(..) => { cx.span_bug(span, "tuple in a path in generic `deriving`") } + } + } +} + + +fn mk_ty_param(cx: &ExtCtxt, span: Span, name: &str, sized: ast::Sized, bounds: &[Path], + self_ident: Ident, self_generics: &Generics) -> ast::TyParam { + let bounds = + bounds.iter().map(|b| { + let path = b.to_path(cx, span, self_ident, self_generics); + cx.typarambound(path) + }).collect(); + cx.typaram(span, cx.ident_of(name), sized, bounds, None) +} + +fn mk_generics(lifetimes: Vec , ty_params: Vec ) -> Generics { + Generics { + lifetimes: lifetimes, + ty_params: OwnedSlice::from_vec(ty_params) + } +} + +/// Lifetimes and bounds on type parameters +pub struct LifetimeBounds<'a> { + pub lifetimes: Vec<&'a str>, + pub bounds: Vec<(&'a str, ast::Sized, Vec>)>, +} + +impl<'a> LifetimeBounds<'a> { + pub fn empty() -> LifetimeBounds<'static> { + LifetimeBounds { + lifetimes: Vec::new(), bounds: Vec::new() + } + } + pub fn to_generics(&self, + cx: &ExtCtxt, + span: Span, + self_ty: Ident, + self_generics: &Generics) + -> Generics { + let lifetimes = self.lifetimes.iter().map(|lt| { + cx.lifetime(span, cx.ident_of(*lt).name) + }).collect(); + let ty_params = self.bounds.iter().map(|t| { + match t { + &(ref name, sized, ref bounds) => { + mk_ty_param(cx, + span, + *name, + sized, + bounds.as_slice(), + self_ty, + self_generics) + } + } + }).collect(); + mk_generics(lifetimes, ty_params) + } +} + + +pub fn get_explicit_self(cx: &ExtCtxt, span: Span, self_ptr: &Option) + -> (@Expr, ast::ExplicitSelf) { + let self_path = cx.expr_self(span); + match *self_ptr { + None => { + (self_path, respan(span, ast::SelfValue)) + } + Some(ref ptr) => { + let self_ty = respan( + span, + match *ptr { + Send => ast::SelfUniq, + Borrowed(ref lt, mutbl) => { + let lt = lt.map(|s| cx.lifetime(span, cx.ident_of(s).name)); + ast::SelfRegion(lt, mutbl) + } + }); + let self_expr = cx.expr_deref(span, self_path); + (self_expr, self_ty) + } + } +} diff --git a/src/libsyntax/ext/deriving/ty.rs b/src/libsyntax/ext/deriving/ty.rs deleted file mode 100644 index 602245b4c47..00000000000 --- a/src/libsyntax/ext/deriving/ty.rs +++ /dev/null @@ -1,267 +0,0 @@ -// Copyright 2013 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -/*! -A mini version of ast::Ty, which is easier to use, and features an -explicit `Self` type to use when specifying impls to be derived. -*/ - -use ast; -use ast::{P,Expr,Generics,Ident}; -use ext::base::ExtCtxt; -use ext::build::AstBuilder; -use codemap::{Span,respan}; -use owned_slice::OwnedSlice; - - -/// The types of pointers -pub enum PtrTy<'a> { - Send, // ~ - Borrowed(Option<&'a str>, ast::Mutability), // &['lifetime] [mut] -} - -/// A path, e.g. `::std::option::Option::` (global). Has support -/// for type parameters and a lifetime. -pub struct Path<'a> { - pub path: Vec<&'a str> , - pub lifetime: Option<&'a str>, - pub params: Vec>>, - pub global: bool, -} - -impl<'a> Path<'a> { - pub fn new<'r>(path: Vec<&'r str> ) -> Path<'r> { - Path::new_(path, None, Vec::new(), true) - } - pub fn new_local<'r>(path: &'r str) -> Path<'r> { - Path::new_(vec!( path ), None, Vec::new(), false) - } - pub fn new_<'r>(path: Vec<&'r str> , - lifetime: Option<&'r str>, - params: Vec>>, - global: bool) - -> Path<'r> { - Path { - path: path, - lifetime: lifetime, - params: params, - global: global - } - } - - pub fn to_ty(&self, - cx: &ExtCtxt, - span: Span, - self_ty: Ident, - self_generics: &Generics) - -> P { - cx.ty_path(self.to_path(cx, span, self_ty, self_generics), None) - } - pub fn to_path(&self, - cx: &ExtCtxt, - span: Span, - self_ty: Ident, - self_generics: &Generics) - -> ast::Path { - let idents = self.path.iter().map(|s| cx.ident_of(*s)).collect(); - let lt = mk_lifetimes(cx, span, &self.lifetime); - let tys = self.params.iter().map(|t| t.to_ty(cx, span, self_ty, self_generics)).collect(); - - cx.path_all(span, self.global, idents, lt, tys) - } -} - -/// A type. Supports pointers (except for *), Self, and literals -pub enum Ty<'a> { - Self, - // &/Box/@ Ty - Ptr(Box>, PtrTy<'a>), - // mod::mod::Type<[lifetime], [Params...]>, including a plain type - // parameter, and things like `int` - Literal(Path<'a>), - // includes nil - Tuple(Vec> ) -} - -pub fn borrowed_ptrty<'r>() -> PtrTy<'r> { - Borrowed(None, ast::MutImmutable) -} -pub fn borrowed<'r>(ty: Box>) -> Ty<'r> { - Ptr(ty, borrowed_ptrty()) -} - -pub fn borrowed_explicit_self<'r>() -> Option>> { - Some(Some(borrowed_ptrty())) -} - -pub fn borrowed_self<'r>() -> Ty<'r> { - borrowed(box Self) -} - -pub fn nil_ty() -> Ty<'static> { - Tuple(Vec::new()) -} - -fn mk_lifetime(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Option { - match *lt { - Some(ref s) => Some(cx.lifetime(span, cx.ident_of(*s).name)), - None => None - } -} - -fn mk_lifetimes(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Vec { - match *lt { - Some(ref s) => vec!(cx.lifetime(span, cx.ident_of(*s).name)), - None => vec!() - } -} - -impl<'a> Ty<'a> { - pub fn to_ty(&self, - cx: &ExtCtxt, - span: Span, - self_ty: Ident, - self_generics: &Generics) - -> P { - match *self { - Ptr(ref ty, ref ptr) => { - let raw_ty = ty.to_ty(cx, span, self_ty, self_generics); - match *ptr { - Send => { - cx.ty_uniq(span, raw_ty) - } - Borrowed(ref lt, mutbl) => { - let lt = mk_lifetime(cx, span, lt); - cx.ty_rptr(span, raw_ty, lt, mutbl) - } - } - } - Literal(ref p) => { p.to_ty(cx, span, self_ty, self_generics) } - Self => { - cx.ty_path(self.to_path(cx, span, self_ty, self_generics), None) - } - Tuple(ref fields) => { - let ty = if fields.is_empty() { - ast::TyNil - } else { - ast::TyTup(fields.iter() - .map(|f| f.to_ty(cx, span, self_ty, self_generics)) - .collect()) - }; - - cx.ty(span, ty) - } - } - } - - pub fn to_path(&self, - cx: &ExtCtxt, - span: Span, - self_ty: Ident, - self_generics: &Generics) - -> ast::Path { - match *self { - Self => { - let self_params = self_generics.ty_params.map(|ty_param| { - cx.ty_ident(span, ty_param.ident) - }); - let lifetimes = self_generics.lifetimes.clone(); - - cx.path_all(span, false, vec!(self_ty), lifetimes, - self_params.into_vec()) - } - Literal(ref p) => { - p.to_path(cx, span, self_ty, self_generics) - } - Ptr(..) => { cx.span_bug(span, "pointer in a path in generic `deriving`") } - Tuple(..) => { cx.span_bug(span, "tuple in a path in generic `deriving`") } - } - } -} - - -fn mk_ty_param(cx: &ExtCtxt, span: Span, name: &str, sized: ast::Sized, bounds: &[Path], - self_ident: Ident, self_generics: &Generics) -> ast::TyParam { - let bounds = - bounds.iter().map(|b| { - let path = b.to_path(cx, span, self_ident, self_generics); - cx.typarambound(path) - }).collect(); - cx.typaram(span, cx.ident_of(name), sized, bounds, None) -} - -fn mk_generics(lifetimes: Vec , ty_params: Vec ) -> Generics { - Generics { - lifetimes: lifetimes, - ty_params: OwnedSlice::from_vec(ty_params) - } -} - -/// Lifetimes and bounds on type parameters -pub struct LifetimeBounds<'a> { - pub lifetimes: Vec<&'a str>, - pub bounds: Vec<(&'a str, ast::Sized, Vec>)>, -} - -impl<'a> LifetimeBounds<'a> { - pub fn empty() -> LifetimeBounds<'static> { - LifetimeBounds { - lifetimes: Vec::new(), bounds: Vec::new() - } - } - pub fn to_generics(&self, - cx: &ExtCtxt, - span: Span, - self_ty: Ident, - self_generics: &Generics) - -> Generics { - let lifetimes = self.lifetimes.iter().map(|lt| { - cx.lifetime(span, cx.ident_of(*lt).name) - }).collect(); - let ty_params = self.bounds.iter().map(|t| { - match t { - &(ref name, sized, ref bounds) => { - mk_ty_param(cx, - span, - *name, - sized, - bounds.as_slice(), - self_ty, - self_generics) - } - } - }).collect(); - mk_generics(lifetimes, ty_params) - } -} - - -pub fn get_explicit_self(cx: &ExtCtxt, span: Span, self_ptr: &Option) - -> (@Expr, ast::ExplicitSelf) { - let self_path = cx.expr_self(span); - match *self_ptr { - None => { - (self_path, respan(span, ast::SelfValue)) - } - Some(ref ptr) => { - let self_ty = respan( - span, - match *ptr { - Send => ast::SelfUniq, - Borrowed(ref lt, mutbl) => { - let lt = lt.map(|s| cx.lifetime(span, cx.ident_of(s).name)); - ast::SelfRegion(lt, mutbl) - } - }); - let self_expr = cx.expr_deref(span, self_path); - (self_expr, self_ty) - } - } -} diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 6e7e72bd2e8..6bc08741c07 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -95,6 +95,8 @@ pub fn expand_include(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) &res_rel_file(cx, sp, &Path::new(file)), + true, + None, sp); base::MacExpr::new(p.parse_expr()) } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index d8a9f69e293..8e139b049c5 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -184,8 +184,13 @@ pub fn new_parser_from_file<'a>(sess: &'a ParseSess, pub fn new_sub_parser_from_file<'a>(sess: &'a ParseSess, cfg: ast::CrateConfig, path: &Path, + owns_directory: bool, + module_name: Option, sp: Span) -> Parser<'a> { - filemap_to_parser(sess, file_to_filemap(sess, path, Some(sp)), cfg) + let mut p = filemap_to_parser(sess, file_to_filemap(sess, path, Some(sp)), cfg); + p.owns_directory = owns_directory; + p.root_module_name = module_name; + p } /// Given a filemap and config, return a parser diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 92e5f8da6aa..c42febcd607 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -313,6 +313,8 @@ pub fn Parser<'a>( obsolete_set: HashSet::new(), mod_path_stack: Vec::new(), open_braces: Vec::new(), + owns_directory: true, + root_module_name: None, } } @@ -342,6 +344,13 @@ pub struct Parser<'a> { pub mod_path_stack: Vec, /// Stack of spans of open delimiters. Used for error message. pub open_braces: Vec, + /// Flag if this parser "owns" the directory that it is currently parsing + /// in. This will affect how nested files are looked up. + pub owns_directory: bool, + /// Name of the root module this parser originated from. If `None`, then the + /// name is not known. This does not change while the parser is descending + /// into modules, and sub-parsers have new values for this name. + pub root_module_name: Option, } fn is_plain_ident_or_underscore(t: &token::Token) -> bool { @@ -4179,9 +4188,12 @@ impl<'a> Parser<'a> { self.push_mod_path(id, outer_attrs); self.expect(&token::LBRACE); let mod_inner_lo = self.span.lo; + let old_owns_directory = self.owns_directory; + self.owns_directory = true; let (inner, next) = self.parse_inner_attrs_and_next(); let m = self.parse_mod_items(token::RBRACE, next, mod_inner_lo); self.expect(&token::RBRACE); + self.owns_directory = old_owns_directory; self.pop_mod_path(); (id, ItemMod(m), Some(inner)) } @@ -4211,11 +4223,11 @@ impl<'a> Parser<'a> { prefix.pop(); let mod_path = Path::new(".").join_many(self.mod_path_stack.as_slice()); let dir_path = prefix.join(&mod_path); - let file_path = match ::attr::first_attr_value_str_by_name( + let mod_string = token::get_ident(id); + let (file_path, owns_directory) = match ::attr::first_attr_value_str_by_name( outer_attrs, "path") { - Some(d) => dir_path.join(d), + Some(d) => (dir_path.join(d), true), None => { - let mod_string = token::get_ident(id); let mod_name = mod_string.get().to_owned(); let default_path_str = mod_name + ".rs"; let secondary_path_str = mod_name + "/mod.rs"; @@ -4223,9 +4235,30 @@ impl<'a> Parser<'a> { let secondary_path = dir_path.join(secondary_path_str.as_slice()); let default_exists = default_path.exists(); let secondary_exists = secondary_path.exists(); + + if !self.owns_directory { + self.span_err(id_sp, + "cannot declare a new module at this location"); + let this_module = match self.mod_path_stack.last() { + Some(name) => name.get().to_strbuf(), + None => self.root_module_name.get_ref().clone(), + }; + self.span_note(id_sp, + format!("maybe move this module `{0}` \ + to its own directory via \ + `{0}/mod.rs`", this_module)); + if default_exists || secondary_exists { + self.span_note(id_sp, + format!("... or maybe `use` the module \ + `{}` instead of possibly \ + redeclaring it", mod_name)); + } + self.abort_if_errors(); + } + match (default_exists, secondary_exists) { - (true, false) => default_path, - (false, true) => secondary_path, + (true, false) => (default_path, false), + (false, true) => (secondary_path, true), (false, false) => { self.span_fatal(id_sp, format!("file not found for module `{}`", mod_name)); } @@ -4238,11 +4271,14 @@ impl<'a> Parser<'a> { } }; - self.eval_src_mod_from_path(file_path, id_sp) + self.eval_src_mod_from_path(file_path, owns_directory, + mod_string.get().to_strbuf(), id_sp) } fn eval_src_mod_from_path(&mut self, path: Path, + owns_directory: bool, + name: StrBuf, id_sp: Span) -> (ast::Item_, Vec ) { let mut included_mod_stack = self.sess.included_mod_stack.borrow_mut(); match included_mod_stack.iter().position(|p| *p == path) { @@ -4265,6 +4301,8 @@ impl<'a> Parser<'a> { new_sub_parser_from_file(self.sess, self.cfg.clone(), &path, + owns_directory, + Some(name), id_sp); let mod_inner_lo = p0.span.lo; let (mod_attrs, next) = p0.parse_inner_attrs_and_next(); diff --git a/src/test/compile-fail/circular_modules_main.rs b/src/test/compile-fail/circular_modules_main.rs index bc9f3247db7..7296ea655c2 100644 --- a/src/test/compile-fail/circular_modules_main.rs +++ b/src/test/compile-fail/circular_modules_main.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +#[path = "circular_modules_hello.rs"] mod circular_modules_hello; //~ERROR: circular modules pub fn hi_str() -> StrBuf { diff --git a/src/test/compile-fail/mod_file_not_owning.rs b/src/test/compile-fail/mod_file_not_owning.rs new file mode 100644 index 00000000000..adbcedd91f2 --- /dev/null +++ b/src/test/compile-fail/mod_file_not_owning.rs @@ -0,0 +1,15 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// error-pattern: cannot declare a new module at this location + +mod mod_file_not_owning_aux1; + +fn main() {} diff --git a/src/test/compile-fail/mod_file_not_owning_aux1.rs b/src/test/compile-fail/mod_file_not_owning_aux1.rs new file mode 100644 index 00000000000..2d522be6dc5 --- /dev/null +++ b/src/test/compile-fail/mod_file_not_owning_aux1.rs @@ -0,0 +1,13 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// ignore-test this is not a test + +mod mod_file_not_owning_aux2; diff --git a/src/test/compile-fail/mod_file_not_owning_aux2.rs b/src/test/compile-fail/mod_file_not_owning_aux2.rs new file mode 100644 index 00000000000..41401d640f6 --- /dev/null +++ b/src/test/compile-fail/mod_file_not_owning_aux2.rs @@ -0,0 +1,11 @@ +// 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// ignore-test this is not a test diff --git a/src/test/run-pass/mod_dir_simple/load_another_mod.rs b/src/test/run-pass/mod_dir_simple/load_another_mod.rs index c11b1e8c074..ca45864a5a1 100644 --- a/src/test/run-pass/mod_dir_simple/load_another_mod.rs +++ b/src/test/run-pass/mod_dir_simple/load_another_mod.rs @@ -8,4 +8,5 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#[path = "test.rs"] pub mod test; -- cgit 1.4.1-3-g733a5