content
stringlengths 12
392k
| id
int64 0
1.08k
|
|---|---|
fn main() {
func_2();
}
| 400
|
pub fn spec() -> Result<()> {
use project::spec::*;
let luigi = try!(setup_luigi());
//let projects = super::execute(||luigi.open_projects(StorageDir::All));
let projects = try!(luigi.open_projects(StorageDir::Working));
for project in projects{
info!("{}", project.dir().display());
let yaml = project.yaml();
client::validate(&yaml).map_err(|errors|for error in errors{
println!(" error: {}", error);
}).unwrap();
client::full_name(&yaml);
client::first_name(&yaml);
client::title(&yaml);
client::email(&yaml);
hours::caterers_string(&yaml);
invoice::number_long_str(&yaml);
invoice::number_str(&yaml);
offer::number(&yaml);
project.age().map(|a|format!("{} days", a)).unwrap();
project.date().map(|d|d.year().to_string()).unwrap();
project.sum_sold().map(|c|util::currency_to_string(&c)).unwrap();
project::manager(&yaml).map(|s|s.to_owned()).unwrap();
project::name(&yaml).map(|s|s.to_owned()).unwrap();
}
Ok(())
}
| 401
|
pub fn write_bool<W>(wr: &mut W, val: bool) -> Result<(), FixedValueWriteError>
where W: Write
{
match val {
true => write_fixval(wr, Marker::True),
false => write_fixval(wr, Marker::False)
}
}
| 402
|
pub fn write_i64<W>(wr: &mut W, val: i64) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_marker(wr, Marker::I64));
write_data_i64(wr, val)
}
| 403
|
pub fn benchmark(c: &mut Criterion, mode: Mode) {
match mode {
Mode::MetricsOff => {
disable_metrics();
disable_metrics_tracing_integration();
}
Mode::MetricsNoTracingIntegration => {
disable_metrics_tracing_integration();
}
Mode::MetricsOn => {}
}
boot();
let metrics_core_enabled = mode != Mode::MetricsOff;
assert_eq!(
vector::metrics::get_controller().is_ok(),
metrics_core_enabled,
"the presence of a controller must correspond to whether metrics core is on or off"
);
let bench_name = mode.as_str();
bench_topology(c, bench_name);
bench_micro(c, bench_name);
}
| 404
|
fn lz_string_base_64() {
compression_tests(
|s| lz_str::compress_to_base64(s).into(),
|s| {
lz_str::decompress_from_base64(&s.to_utf8_string().expect("Valid UTF16 String"))
.map(ByteString::from)
},
false,
);
}
| 405
|
pub fn make_buffer_with<T, F: FnMut () -> T> (len: usize, mut f: F) -> Box<[T]> {
make_buffer_with_indexed(len, move |_| f())
}
| 406
|
pub fn get_and_extract_wix(path: &Path) -> crate::Result<()> {
common::print_info("Verifying wix package")?;
let data = download_and_verify(WIX_URL, WIX_SHA256)?;
common::print_info("extracting WIX")?;
extract_zip(&data, path)
}
| 407
|
fn main() {
const A_ID: TypeId = TypeId::of::<A>();
//~^ ERROR `std::any::TypeId::of` is not yet stable as a const fn
}
| 408
|
fn map_simple() -> Result<(), Box<dyn Error>> {
let mut cmd = Command::cargo_bin("mrf")?;
cmd.arg("map").arg("test-001").arg("{}{=_}{}");
cmd.assert()
.success()
.stdout(predicate::eq("test-001\0test_001\0"));
Ok(())
}
| 409
|
fn add_twice() {
let project = project("add").with_fuzz().build();
project
.cargo_fuzz()
.arg("add")
.arg("new_fuzz_target")
.assert()
.success();
assert!(project.fuzz_target_path("new_fuzz_target").is_file());
project
.cargo_fuzz()
.arg("add")
.arg("new_fuzz_target")
.assert()
.stderr(
predicate::str::contains("could not add target")
.and(predicate::str::contains("File exists (os error 17)")),
)
.failure();
}
| 410
|
pub unsafe fn arm_set_tls(data: *mut c_void) -> io::Result<()> {
imp::syscalls::tls::arm_set_tls(data)
}
| 411
|
fn fuzzy_score(
choice_ch: char,
choice_idx: usize,
choice_prev_ch: char,
pat_ch: char,
pat_idx: usize,
_pat_prev_ch: char,
) -> i64 {
let mut score = BONUS_MATCHED;
let choice_prev_ch_type = char_type_of(choice_prev_ch);
let choice_role = char_role(choice_prev_ch, choice_ch);
if pat_ch == choice_ch {
if pat_ch.is_uppercase() {
score += BONUS_UPPER_MATCH;
} else {
score += BONUS_CASE_MATCH;
}
} else {
score += PENALTY_CASE_UNMATCHED;
}
// apply bonus for camelCases
if choice_role == CharRole::Head {
score += BONUS_CAMEL;
}
// apply bonus for matches after a separator
if choice_prev_ch_type == CharType::Separ {
score += BONUS_SEPARATOR;
}
if pat_idx == 0 {
score += max((choice_idx as i64) * PENALTY_LEADING, PENALTY_MAX_LEADING);
}
score
}
| 412
|
fn read_vector<T>() -> Vec<T>
where
T: std::str::FromStr,
T::Err: std::fmt::Debug,
{
let mut buf = String::with_capacity(100);
stdin().read_line(&mut buf).unwrap();
return buf.split_whitespace().map(|s| s.parse().unwrap()).collect();
}
| 413
|
fn state_from_snapshot<F>(
snapshot: ::fidl::InterfacePtr<PageSnapshot_Client>,
key: Vec<u8>,
done: F,
) where
F: Send + FnOnce(Result<Option<Engine>, ()>) + 'static,
{
assert_eq!(PageSnapshot_Metadata::VERSION, snapshot.version);
let mut snapshot_proxy = PageSnapshot_new_Proxy(snapshot.inner);
// TODO get a reference when too big
snapshot_proxy.get(key).with(move |raw_res| {
let state = match raw_res.map(|res| ledger::value_result(res)) {
// the .ok() has the behavior of acting like invalid state is empty
// and thus deleting invalid state and overwriting it with good state
Ok(Ok(Some(buf))) => Ok(buf_to_state(&buf).ok()),
Ok(Ok(None)) => {
info!("No state in conflicting page");
Ok(None)
}
Err(err) => {
warn!("FIDL failed on initial response: {:?}", err);
Err(())
}
Ok(Err(err)) => {
warn!("Ledger failed to retrieve key: {:?}", err);
Err(())
}
};
done(state);
});
}
| 414
|
fn
default
(
)
-
>
AtomicCell
<
T
>
{
AtomicCell
:
:
new
(
T
:
:
default
(
)
)
}
}
impl
<
T
>
From
<
T
>
for
AtomicCell
<
T
>
{
#
[
inline
]
fn
from
(
val
:
T
)
-
>
AtomicCell
<
T
>
{
AtomicCell
:
:
new
(
val
)
}
}
impl
<
T
:
Copy
+
fmt
:
:
Debug
>
fmt
:
:
Debug
for
AtomicCell
<
T
>
{
fn
fmt
(
&
self
f
:
&
mut
fmt
:
:
Formatter
<
'
_
>
)
-
>
fmt
:
:
Result
{
f
.
debug_struct
(
"
AtomicCell
"
)
.
field
(
"
value
"
&
self
.
load
(
)
)
.
finish
(
)
}
}
const
fn
can_transmute
<
A
B
>
(
)
-
>
bool
{
(
mem
:
:
size_of
:
:
<
A
>
(
)
=
=
mem
:
:
size_of
:
:
<
B
>
(
)
)
&
(
mem
:
:
align_of
:
:
<
A
>
(
)
>
=
mem
:
:
align_of
:
:
<
B
>
(
)
)
}
| 415
|
fn run_light(
wix_toolset_path: &Path,
build_path: &Path,
wixobjs: &[&str],
output_path: &Path,
) -> crate::Result<PathBuf> {
let light_exe = wix_toolset_path.join("light.exe");
let mut args: Vec<String> = vec![
"-ext".to_string(),
"WixUIExtension".to_string(),
"-o".to_string(),
output_path.display().to_string(),
];
for p in wixobjs {
args.push(p.to_string());
}
let mut cmd = Command::new(&light_exe);
cmd
.args(&args)
.stdout(Stdio::piped())
.current_dir(build_path);
common::print_info(format!("running light to produce {}", output_path.display()).as_str())?;
common::execute_with_output(&mut cmd)
.map(|_| output_path.to_path_buf())
.map_err(|_| crate::Error::LightError)
}
| 416
|
pub async fn accept_async_with_config<S>(
stream: S,
config: Option<WebSocketConfig>,
) -> Result<WebSocketStream<TokioAdapter<S>>, Error>
where
S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
{
accept_hdr_async_with_config(stream, NoCallback, config).await
}
| 417
|
fn is_permutation(input1: &str, input2: &str) -> bool {
if input1.len() != input2.len() {
return false;
}
let count_map_input1 = count_char(input1);
let count_map_input2 = count_char(input2);
if count_map_input1 == count_map_input2 {
return true;
}
false
}
| 418
|
fn openssl_dir() -> Result<String, FrumError> {
#[cfg(target_os = "macos")]
return Ok(String::from_utf8_lossy(
&Command::new("brew")
.arg("--prefix")
.arg("openssl")
.output()
.map_err(FrumError::IoError)?
.stdout,
)
.trim()
.to_string());
#[cfg(not(target_os = "macos"))]
return Ok("/usr/local".to_string());
}
| 419
|
pub fn accessible(node: Node) -> Node {
println!("building node:accessible, node: {:?}", node);
return match node {
Node::Ident(n_ident_value) => {
// TODO DUMMY
// TODO handle static_env
let node = Node::LVar(n_ident_value);
return node;
}
_ => node
};
}
| 420
|
pub fn nbt_decode_enum(input: TokenStream) -> TokenStream {
let ast: syn::DeriveInput = syn::parse(input).unwrap();
let receiver = nbt_decode::NbtDecodeReceiver::from_derive_input(&ast).unwrap();
let result = wrap_use(receiver.ident, "nbtdecode", &receiver);
let mut tokens = quote::Tokens::new();
tokens.append_all(&[result]);
tokens.into()
}
| 421
|
fn main() {
let now = Instant::now();
// This is our data to process.
// We will calculate the sum of all digits via a threaded map-reduce algorithm.
// Each whitespace separated chunk will be handled in a different thread.
//
// TODO: see what happens to the output if you insert spaces!
let data = "86967897737416471853297327050364959
11861322575564723963297542624962850
70856234701860851907960690014725639
38397966707106094172783238747669219
52380795257888236525459303330302837
58495327135744041048897885734297812
69920216438980873548808413720956532
16278424637452589860345374828574668";
// Make a vector to hold the child-threads which we will spawn.
let mut children = vec![];
/*************************************************************************
* "Map" phase
*
* Divide our data into segments, and apply initial processing
************************************************************************/
// split our data into segments for individual calculation
// each chunk will be a reference (&str) into the actual data
let chunked_data = data.split_whitespace();
// Iterate over the data segments.
// .enumerate() adds the current loop index to whatever is iterated
// the resulting tuple "(index, element)" is then immediately
// "destructured" into two variables, "i" and "data_segment" with a
// "destructuring assignment"
for (i, data_segment) in chunked_data.enumerate() {
println!("data segment {} is \"{}\"", i, data_segment);
// Process each data segment in a separate thread
//
// spawn() returns a handle to the new thread,
// which we MUST keep to access the returned value
//
// 'move || -> u32' is syntax for a closure that:
// * takes no arguments ('||')
// * takes ownership of its captured variables ('move') and
// * returns an unsigned 32-bit integer ('-> u32')
//
// Rust is smart enough to infer the '-> u32' from
// the closure itself so we could have left that out.
//
// TODO: try removing the 'move' and see what happens
children.push(thread::spawn(move || -> u32 {
// Calculate the intermediate sum of this segment:
let result = data_segment
// iterate over the characters of our segment..
.chars()
// .. convert text-characters to their number value..
.map(|c| c.to_digit(10).expect("should be a digit"))
// .. and sum the resulting iterator of numbers
.sum();
// println! locks stdout, so no text-interleaving occurs
println!("processed segment {}, result={}", i, result);
// "return" not needed, because Rust is an "expression language", the
// last evaluated expression in each block is automatically its value.
result
}));
}
/*************************************************************************
* "Reduce" phase
*
* Collect our intermediate results, and combine them into a final result
************************************************************************/
// collect each thread's intermediate results into a new Vec
let mut intermediate_sums = vec![];
for child in children {
// collect each child thread's return-value
let intermediate_sum = child.join().unwrap();
intermediate_sums.push(intermediate_sum);
}
// combine all intermediate sums into a single final sum.
//
// we use the "turbofish" ::<> to provide sum() with a type hint.
//
// TODO: try without the turbofish, by instead explicitly
// specifying the type of intermediate_sums
let final_result = intermediate_sums.iter().sum::<u32>();
println!("Final sum result: {}", final_result);
println!("{}", now.elapsed().as_secs());
}
| 422
|
fn main() {
input! {
n: usize,
s: [String; n],
}
// (ユーザ名, 登録日) のマップを作る
// 降順にして一回だけ走査し、同じ値だった場合は上書きする
let mut map: HashMap<String, usize> = HashMap::new();
for i in (0..n).rev() {
map.insert(s[i].to_string(), i + 1);
}
// 登録日の昇順でソートする
let mut vec = map.into_iter().collect::<Vec<_>>();
vec.sort_by(|a, b| a.1.cmp(&b.1));
for (_, date) in vec.iter() {
println!("{}", date);
}
}
| 423
|
pub async fn handle_request<T>(
req: Request<T>,
client: &Client,
config: &ServerConfig,
) -> Result<Response<Body>, Error> {
match req.uri().path() {
// JSON API with the status of the network.
"/data" => {
let servers = schema::get_servers(client)
.await?
.into_iter()
.map(|s| NetworkStatusServer {
name: s.name,
subnet: s.subnet_addr.to_string(),
subnet_len: s.subnet_len,
address: s.address.to_string(),
endpoint: s.public_address.to_string(),
endpoint_port: s.public_port,
})
.collect();
let clients = schema::get_clients(client, None::<&str>)
.await?
.into_iter()
.map(|c| NetworkStatusClient {
name: c.client.name,
server: c.server,
address: c.address.to_string(),
})
.collect();
let status = NetworkStatus {
servers,
clients,
base_domain: config.base_domain.clone(),
};
Ok(Response::builder()
.status(200)
.header("Content-Type", "application/json")
.body(Body::from(serde_json::to_string_pretty(&status)?))
.unwrap())
}
// Generate the client configuration for a given username.
url if url.starts_with("/conf/") => {
let name = &url[6..];
let conf = gen_client_config(config, client, name.to_owned(), None).await;
match conf {
Ok(conf) => Ok(Response::builder()
.status(200)
.body(Body::from(conf))
.unwrap()),
Err(err) => Ok(Response::builder()
.status(404)
.body(Body::from(err.to_string()))
.unwrap()),
}
}
// Any other static file.
_ => {
// if asking for an index, manually change the file name.
let path = if req.uri().path() == "/" {
"/index.html"
} else {
req.uri().path()
};
let path = config
.web_static_dir
.join(&path[1..])
.canonicalize()
.unwrap_or_default();
if path.starts_with(&config.web_static_dir) {
if let Ok(mut file) = File::open(&path).await {
debug!("Sending file {:?}", path);
let mut buf = Vec::new();
if file.read_to_end(&mut buf).await.is_ok() {
return Ok(Response::new(buf.into()));
}
}
}
warn!("404 File Not Found: {} -> {:?}", req.uri().path(), path);
let mut not_found = Response::default();
*not_found.status_mut() = StatusCode::NOT_FOUND;
Ok(not_found)
}
}
}
| 424
|
pub fn assert_binary_arguments<D: Display>(name: D, actual: usize) -> Result<()> {
if actual != 2 {
return Err(ErrorCode::NumberArgumentsNotMatch(format!(
"{} expect to have two arguments, but got {}",
name, actual
)));
}
Ok(())
}
| 425
|
pub fn acrn_create_dir(path: &str, recursive: bool) -> Result<(), String> {
if recursive {
fs::create_dir_all(path).map_err(|e| e.to_string())
} else {
fs::create_dir(path).map_err(|e| e.to_string())
}
}
| 426
|
fn inc_14() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Indirect(SI, Some(OperandSize::Word), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[255, 4], OperandSize::Word)
}
| 427
|
pub extern "x86-interrupt" fn ISR15() { CommonExceptionHandler(15); }
| 428
|
pub(crate) fn format_path_ref(path: &Path) -> String {
let mut path = path.clone();
// Generics and path arguments are unsupported
if let Some(last_segment) = path.segments.last_mut() {
last_segment.arguments = PathArguments::None;
}
// :: are not officially supported in the spec
// See: https://github.com/juhaku/utoipa/pull/187#issuecomment-1173101405
path.to_token_stream().to_string().replace(" :: ", ".")
}
| 429
|
fn create_mesh_buffer_verts(
chunk: &Chunk,
device: &wgpu::Device,
queue: &wgpu::Queue,
) -> MeshBufferVerts {
// Calculate total length of buffer e.g. a full chunk of different voxels. This way a new buffer only has to be created when the voxel capacity is changed.
let verts = Mesh::verts(chunk);
let vert_len = verts.len();
let single_cube_verts = Mesh::cube_verts().len();
let single_cube_color_verts = (single_cube_verts / 3) * std::mem::size_of::<PaletteIndexType>(); // One PaletteIndexType per 3 verts
let max_voxels = {
let (x, y, z) = chunk.capacity();
x * y * z
};
let max_buf_size =
(single_cube_verts + single_cube_color_verts) * max_voxels * std::mem::size_of::<f32>();
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: None,
mapped_at_creation: false,
size: max_buf_size as u64,
usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
});
if vert_len > 0 {
queue.write_buffer(&buffer, 0, bytemuck::cast_slice(&verts));
}
MeshBufferVerts {
buffer,
vert_len,
max_capacity: chunk.capacity(),
}
}
| 430
|
fn part2(_filename: &Path) -> String {
String::from("Start The Blender")
}
| 431
|
fn de_board(raw: Vec<usize>, t: isize, l: i32, width: u8, height: u8) -> game::Board {
let mut res = game::Board::new(t, l, width, height);
res.pieces = raw
.into_iter()
.map(|x| game::Piece::from(x))
.collect();
res
}
| 432
|
pub fn count_ones(mut x: u64) -> usize {
x = x - ((x & 0xAAAA_AAAA_AAAA_AAAA) >> 1);
x = (x & 0x3333_3333_3333_3333) + ((x >> 2) & 0x3333_3333_3333_3333);
x = (x + (x >> 4)) & 0x0F0F_0F0F_0F0F_0F0F;
(x.wrapping_mul(L8) >> 56) as usize
}
| 433
|
pub fn median_filter_hist_optimized(frame : ImageBuffer<Luma<u8>, Vec<u8>>, kernel_size : usize) -> ImageBuffer<Luma<u8>, Vec<u8>> {
//assert!(kernel_size % 2 == 1, "Kernel size must be odd");
let mut result = ImageBuffer::new(640, 480);
let kernel_offset = ((kernel_size - 1) / 2) as i32;
for i in 0..640 {
let mut hist = Histogram::new();
for k in (i as i32 - kernel_offset)..(i as i32 + kernel_offset + 1) {
for l in 0..(kernel_offset + 1) {
if check_coordinates(k, l as i32) {
let color = frame[(k as u32, l as u32)].channels()[0];
hist.increment(color);
}
}
}
for j in 0..480 {
let old_column_coord = j as i32 - kernel_offset - 1i32;
let new_column_coord = j as i32 + kernel_offset;
for k in (i as i32 - kernel_offset)..(i as i32 + kernel_offset + 1) {
if check_coordinates(k, old_column_coord) {
let color = frame[(k as u32, old_column_coord as u32)].channels()[0];
hist.decrement(color);
}
}
for k in (i as i32 - kernel_offset)..(i as i32 + kernel_offset + 1) {
if check_coordinates(k, new_column_coord) {
let color = frame[(k as u32, new_column_coord as u32)].channels()[0];
hist.increment(color);
}
}
let median_color = Luma([hist.median()]);
result.put_pixel(i as u32, j as u32, median_color);
}
}
return result;
}
| 434
|
fn main() {
let event_loop = EventLoop::new();
let window = Window::new(&event_loop).unwrap();
let time = Instant::now() + Duration::from_millis(400);
let mut state = State::new(&window);
let id = window.id();
event_loop.run(move |event, _, control_flow| {
match event {
Event::WindowEvent {
ref event,
window_id,
} if window_id == id => if state.input(event) {
*control_flow = ControlFlow::WaitUntil(time);
} else {
match event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::KeyboardInput {
input: i,
..
} => match i {
KeyboardInput {
state: ElementState::Pressed,
virtual_keycode: Some(VirtualKeyCode::Escape),
..
} => *control_flow = ControlFlow::Exit,
_ => *control_flow = ControlFlow::WaitUntil(time),
},
_ => *control_flow = ControlFlow::WaitUntil(time),
}
}
Event::MainEventsCleared => {
state.check_collision();
state.update_instances();
state.update();
state.render();
*control_flow = ControlFlow::WaitUntil(time);
if state.collided {
state.render_finish();
sleep(Duration::from_millis(5000));
*control_flow = ControlFlow::Exit;
}
},
_ => *control_flow = ControlFlow::WaitUntil(time),
}
});
}
| 435
|
fn read_string<P: AsRef<Path>>(path: P) -> io::Result<String> {
//Read file into a string
let mut string = String::new();
File::open(path).and_then(|mut f| f.read_to_string(&mut string)).map(|_| string)
}
| 436
|
fn de_l(raw: f32, even: bool) -> i32 {
if even && raw < 0.0 {
(raw.ceil() - 1.0) as i32
} else {
raw.floor() as i32
}
}
| 437
|
fn build_url(host: &str, page: Option<i32>) -> String {
match page {
Some(p) => format!(
"https://api.binaryedge.io/v2/query/domains/subdomain/{}?page={}",
host, p
),
None => format!(
"https://api.binaryedge.io/v2/query/domains/subdomain/{}",
host
),
}
}
| 438
|
pub fn u8_to_u16(b1: u8, b2: u8) -> u16 {
(u16::from(b1) << 8) | u16::from(b2)
}
| 439
|
fn
test_string
(
)
-
>
Result
<
(
)
>
{
let
db
=
checked_memory_handle
(
)
?
;
let
s
=
"
hello
world
!
"
;
db
.
execute
(
"
INSERT
INTO
foo
(
t
)
VALUES
(
?
1
)
"
[
s
.
to_owned
(
)
]
)
?
;
let
from
:
String
=
db
.
one_column
(
"
SELECT
t
FROM
foo
"
)
?
;
assert_eq
!
(
from
s
)
;
Ok
(
(
)
)
}
| 440
|
fn main() {
let x = 2.0; // f64
println!("x: {}", x);
let y: f32 = 3.0; // f32
println!("y: {}", y);
let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup;
println!("The value of x is: {}", x);
println!("The value of y is: {}", y);
println!("The value of z is: {}", z);
let a = [1, 2, 3, 4, 5];
let first = a[0];
let second = a[1];
println!("The value of first is: {}", first);
println!("The value of second is: {}", second);
let x: (i32, f64, u8) = (500, 6.4, 1);
let a = x.0;
let b = x.1;
let c = x.2;
println!("The value of a is: {}", a);
println!("The value of b is: {}", b);
println!("The value of c is: {}", c);
}
| 441
|
fn parse_pbs_job_remaining_time(job_id: &str, data: &str) -> anyhow::Result<Duration> {
let data_json: Value = serde_json::from_str(data)?;
let walltime = parse_hms_duration(
data_json["Jobs"][job_id]["Resource_List"]["walltime"]
.as_str()
.ok_or_else(|| anyhow::anyhow!("Could not find walltime key for job {}", job_id))?,
)?;
let used = parse_hms_duration(
data_json["Jobs"][job_id]["resources_used"]["walltime"]
.as_str()
.ok_or_else(|| anyhow::anyhow!("Could not find used time key for job {}", job_id))?,
)?;
if walltime < used {
anyhow::bail!("Pbs: Used time is bigger then walltime");
}
Ok(walltime - used)
}
| 442
|
fn binary_decoding_compatibility_tests_mandatory() {
eprintln!("base64 - old encoding");
let base64_encoding_old_decompressed = "During tattooing, ink is injected into the skin, initiating an immune response, and cells called \"macrophages\" move into the area and \"eat up\" the ink. The macrophages carry some of the ink to the body\'s lymph nodes, but some that are filled with ink stay put, embedded in the skin. That\'s what makes the tattoo visible under the skin. Dalhousie Uiversity\'s Alec Falkenham is developing a topical cream that works by targeting the macrophages that have remained at the site of the tattoo. New macrophages move in to consume the previously pigment-filled macrophages and then migrate to the lymph nodes, eventually taking all the dye with them. \"When comparing it to laser-based tattoo removal, in which you see the burns, the scarring, the blisters, in this case, we\'ve designed a drug that doesn\'t really have much off-target effect,\" he said. \"We\'re not targeting any of the normal skin cells, so you won\'t see a lot of inflammation. In fact, based on the process that we\'re actually using, we don\'t think there will be any inflammation at all and it would actually be anti-inflammatory.";
let base64_encoding_old_compressed = "CIVwTglgdg5gBAFwIYIQezdGAaO0DWeAznlAFYCmAxghQCanqIAWFcR+0u0ECEKWOEih4AtqJBQ2YCkQAOaKEQq5hDKhQA2mklSTb6cAESikVMGjnMkMWUbii0ANzbQmCVkJlIhUBkYoUOBA5ew9XKHwAOjgAFU9Tc0trW10kMDAAT3Y0UTY0ADMWCMJ3TwAjNDpMgHISTUzRKzgoKtlccpAEHLyWIPS2AogDBgB3XmZSQiJkbLku3ApRcvo6Q2hi9k4oGPiUOrhR627TfFlN5FQMOCcIIghyzTZJNbBNjmgY4H1mNBB7tgAVQgLjA9wQtRIAEEnlQ4AAxfRnKDWUTEOBrFyaSyCHzoOQQPSaODmQJojxBUZoMD4EjlbLIMC2PiwTaJCxWGznCndawuOAyUzQQxBcLsXj5Ipiy7oNAxAByFFGDjMHJS50c/I2TCoiiIIF6YrkMlufyIDTgBJgeSgCAAtEMRiqkpzUr4GOERKIIDAwCg2GU2A0mpNWmsiIsXLaQPoLchtvBY5tqmxxh5iqIYkYAOqsES6prpQS8RBoOCaJDKMB28qVwwy66C5z6bgiI6EyaZP7sCgBirgJS4MVEPQZLBDiqaO60MGtlh3El13CjCg1fnhn1SBg+OhgEDwHkYtCyKA1brebTZPlsCRUSaFAp2xnMuAUAoFagIbD2TxEJAQOgs2zVcZBaNBumfCgWUTKBskKTZWjAUxiQ+fMtB0XAiDLLsQEORQzx7NgfGxbp4OgAoK3EARFBiABJEQCjML84FrZQGEUTZjTQDQiBIQ8VxqUCmJjS9gnuWBlzYOh8Ig5gCGKUDxm0FiiNg0gKKQKi+A4/plLUPBuipEBNG3GgRItFZfD4O1yMo0x0CyKIgAAA==";
test_dec_bin_compat(
lz_str::decompress_from_base64,
&base64_encoding_old_decompressed
.encode_utf16()
.collect::<Vec<u16>>(),
base64_encoding_old_compressed,
);
eprintln!("base64");
let base64_encoding_decompressed = "During tattooing, ink is injected into the skin, initiating an immune response, and cells called \"macrophages\" move into the area and \"eat up\" the ink. The macrophages carry some of the ink to the body\'s lymph nodes, but some that are filled with ink stay put, embedded in the skin. That\'s what makes the tattoo visible under the skin. Dalhousie Uiversity\'s Alec Falkenham is developing a topical cream that works by targeting the macrophages that have remained at the site of the tattoo. New macrophages move in to consume the previously pigment-filled macrophages and then migrate to the lymph nodes, eventually taking all the dye with them. \"When comparing it to laser-based tattoo removal, in which you see the burns, the scarring, the blisters, in this case, we\'ve designed a drug that doesn\'t really have much off-target effect,\" he said. \"We\'re not targeting any of the normal skin cells, so you won\'t see a lot of inflammation. In fact, based on the process that we\'re actually using, we don\'t think there will be any inflammation at all and it would actually be anti-inflammatory.";
let base64_encoding_compressed = "CIVwTglgdg5gBAFwIYIQezdGAaO0DWeAznlAFYCmAxghQCanqIAWFcR+0u0ECEKWOEih4AtqJBQ2YCkQAOaKEQq5hDKhQA2mklSTb6cAESikVMGjnMkMWUbii0ANzbQmCVkJlIhUBkYoUOBA5ew9XKHwAOjgAFU9Tc0trW10kMDAAT3Y0UTY0ADMWCMJ3TwAjNDpMgHISTUzRKzgoKtlccpAEHLyWIPS2AogDBgB3XmZSQiJkbLku3ApRcvo6Q2hi9k4oGPiUOrhR627TfFlN5FQMOCcIIghyzTZJNbBNjmgY4H1mNBB7tgAVQgLjA9wQtRIAEEnlQ4AAxfRnKDWUTEOBrFyaSyCHzoOQQPSaODmQJojxBUZoMD4EjlbLIMC2PiwTaJCxWGznCndawuOAyUzQQxBcLsXj5Ipiy7oNAxAByFFGDjMHJS50c/I2TCoiiIIF6YrkMlufyIDTgBJgeSgCAAtEMRiqkpzUr4GOERKIIDAwCg2GU2A0mpNWmsiIsXLaQPoLchtvBY5tqmxxh5iqIYkYAOqsES6prpQS8RBoOCaJDKMB28qVwwy66C5z6bgiI6EyaZP7sCgBirgJS4MVEPQZLBDiqaO60MGtlh3El13CjCg1fnhn1SBg+OhgEDwHkYtCyKA1brebTZPlsCRUSaFAp2xnMuAUAoFagIbD2TxEJAQOgs2zVcZBaNBumfCgWUTKBskKTZWjAUxiQ+fMtB0XAiDLLsQEORQzx7NgfGxbp4OgAoK3EARFBiABJEQCjML84FrZQGEUTZjTQDQiBIQ8VxqUCmJjS9gnuWBlzYOh8Ig5gCGKUDxm0FiiNg0gKKQKi+A4/plLUPBuipEBNG3GgRItFZfD4O1yMo0x0CyKIgA";
test_dec_bin_compat(
lz_str::decompress_from_base64,
&base64_encoding_decompressed
.encode_utf16()
.collect::<Vec<u16>>(),
base64_encoding_compressed,
);
eprintln!("uriEncoding - old encoding");
let uri_encoding_old_decompressed = "During tattooing, ink is injected into the skin, initiating an immune response, and cells called \"macrophages\" move into the area and \"eat up\" the ink. The macrophages carry some of the ink to the body\'s lymph nodes, but some that are filled with ink stay put, embedded in the skin. That\'s what makes the tattoo visible under the skin. Dalhousie Uiversity\'s Alec Falkenham is developing a topical cream that works by targeting the macrophages that have remained at the site of the tattoo. New macrophages move in to consume the previously pigment-filled macrophages and then migrate to the lymph nodes, eventually taking all the dye with them. \"When comparing it to laser-based tattoo removal, in which you see the burns, the scarring, the blisters, in this case, we\'ve designed a drug that doesn\'t really have much off-target effect,\" he said. \"We\'re not targeting any of the normal skin cells, so you won\'t see a lot of inflammation. In fact, based on the process that we\'re actually using, we don\'t think there will be any inflammation at all and it would actually be anti-inflammatory.";
let uri_encoding_old_compressed = "CIVwTglgdg5gBAFwIYIQezdGAaO0DWeAznlAFYCmAxghQCanqIAWFcR+0u0ECEKWOEih4AtqJBQ2YCkQAOaKEQq5hDKhQA2mklSTb6cAESikVMGjnMkMWUbii0ANzbQmCVkJlIhUBkYoUOBA5ew9XKHwAOjgAFU9Tc0trW10kMDAAT3Y0UTY0ADMWCMJ3TwAjNDpMgHISTUzRKzgoKtlccpAEHLyWIPS2AogDBgB3XmZSQiJkbLku3ApRcvo6Q2hi9k4oGPiUOrhR627TfFlN5FQMOCcIIghyzTZJNbBNjmgY4H1mNBB7tgAVQgLjA9wQtRIAEEnlQ4AAxfRnKDWUTEOBrFyaSyCHzoOQQPSaODmQJojxBUZoMD4EjlbLIMC2PiwTaJCxWGznCndawuOAyUzQQxBcLsXj5Ipiy7oNAxAByFFGDjMHJS50c-I2TCoiiIIF6YrkMlufyIDTgBJgeSgCAAtEMRiqkpzUr4GOERKIIDAwCg2GU2A0mpNWmsiIsXLaQPoLchtvBY5tqmxxh5iqIYkYAOqsES6prpQS8RBoOCaJDKMB28qVwwy66C5z6bgiI6EyaZP7sCgBirgJS4MVEPQZLBDiqaO60MGtlh3El13CjCg1fnhn1SBg+OhgEDwHkYtCyKA1brebTZPlsCRUSaFAp2xnMuAUAoFagIbD2TxEJAQOgs2zVcZBaNBumfCgWUTKBskKTZWjAUxiQ+fMtB0XAiDLLsQEORQzx7NgfGxbp4OgAoK3EARFBiABJEQCjML84FrZQGEUTZjTQDQiBIQ8VxqUCmJjS9gnuWBlzYOh8Ig5gCGKUDxm0FiiNg0gKKQKi+A4-plLUPBuipEBNG3GgRItFZfD4O1yMo0x0CyKIgA";
test_dec_bin_compat(
lz_str::decompress_from_encoded_uri_component,
&uri_encoding_old_decompressed
.encode_utf16()
.collect::<Vec<u16>>(),
uri_encoding_old_compressed,
);
eprintln!("uriEncoding");
let uri_encoding_decompressed = "During tattooing, ink is injected into the skin, initiating an immune response, and cells called \"macrophages\" move into the area and \"eat up\" the ink. The macrophages carry some of the ink to the body\'s lymph nodes, but some that are filled with ink stay put, embedded in the skin. That\'s what makes the tattoo visible under the skin. Dalhousie Uiversity\'s Alec Falkenham is developing a topical cream that works by targeting the macrophages that have remained at the site of the tattoo. New macrophages move in to consume the previously pigment-filled macrophages and then migrate to the lymph nodes, eventually taking all the dye with them. \"When comparing it to laser-based tattoo removal, in which you see the burns, the scarring, the blisters, in this case, we\'ve designed a drug that doesn\'t really have much off-target effect,\" he said. \"We\'re not targeting any of the normal skin cells, so you won\'t see a lot of inflammation. In fact, based on the process that we\'re actually using, we don\'t think there will be any inflammation at all and it would actually be anti-inflammatory.";
let uri_encoding_compressed = "CIVwTglgdg5gBAFwIYIQezdGAaO0DWeAznlAFYCmAxghQCanqIAWFcR+0u0ECEKWOEih4AtqJBQ2YCkQAOaKEQq5hDKhQA2mklSTb6cAESikVMGjnMkMWUbii0ANzbQmCVkJlIhUBkYoUOBA5ew9XKHwAOjgAFU9Tc0trW10kMDAAT3Y0UTY0ADMWCMJ3TwAjNDpMgHISTUzRKzgoKtlccpAEHLyWIPS2AogDBgB3XmZSQiJkbLku3ApRcvo6Q2hi9k4oGPiUOrhR627TfFlN5FQMOCcIIghyzTZJNbBNjmgY4H1mNBB7tgAVQgLjA9wQtRIAEEnlQ4AAxfRnKDWUTEOBrFyaSyCHzoOQQPSaODmQJojxBUZoMD4EjlbLIMC2PiwTaJCxWGznCndawuOAyUzQQxBcLsXj5Ipiy7oNAxAByFFGDjMHJS50c-I2TCoiiIIF6YrkMlufyIDTgBJgeSgCAAtEMRiqkpzUr4GOERKIIDAwCg2GU2A0mpNWmsiIsXLaQPoLchtvBY5tqmxxh5iqIYkYAOqsES6prpQS8RBoOCaJDKMB28qVwwy66C5z6bgiI6EyaZP7sCgBirgJS4MVEPQZLBDiqaO60MGtlh3El13CjCg1fnhn1SBg+OhgEDwHkYtCyKA1brebTZPlsCRUSaFAp2xnMuAUAoFagIbD2TxEJAQOgs2zVcZBaNBumfCgWUTKBskKTZWjAUxiQ+fMtB0XAiDLLsQEORQzx7NgfGxbp4OgAoK3EARFBiABJEQCjML84FrZQGEUTZjTQDQiBIQ8VxqUCmJjS9gnuWBlzYOh8Ig5gCGKUDxm0FiiNg0gKKQKi+A4-plLUPBuipEBNG3GgRItFZfD4O1yMo0x0CyKIgAAA$$";
test_dec_bin_compat(
lz_str::decompress_from_encoded_uri_component,
&uri_encoding_decompressed
.encode_utf16()
.collect::<Vec<u16>>(),
uri_encoding_compressed,
);
eprintln!("UInt8Array");
let uint8_array_decompressed = "During tattooing, ink is injected into the skin, initiating an immune response, and cells called \"macrophages\" move into the area and \"eat up\" the ink. The macrophages carry some of the ink to the body\'s lymph nodes, but some that are filled with ink stay put, embedded in the skin. That\'s what makes the tattoo visible under the skin. Dalhousie Uiversity\'s Alec Falkenham is developing a topical cream that works by targeting the macrophages that have remained at the site of the tattoo. New macrophages move in to consume the previously pigment-filled macrophages and then migrate to the lymph nodes, eventually taking all the dye with them. \"When comparing it to laser-based tattoo removal, in which you see the burns, the scarring, the blisters, in this case, we\'ve designed a drug that doesn\'t really have much off-target effect,\" he said. \"We\'re not targeting any of the normal skin cells, so you won\'t see a lot of inflammation. In fact, based on the process that we\'re actually using, we don\'t think there will be any inflammation at all and it would actually be anti-inflammatory.";
let uint8_array_compressed = &[
8, 133, 112, 78, 9, 96, 118, 14, 96, 4, 1, 112, 33, 130, 16, 123, 55, 70, 1, 163, 180, 13,
103, 128, 206, 121, 64, 21, 128, 166, 3, 24, 33, 64, 38, 167, 168, 128, 22, 21, 196, 126,
210, 237, 4, 8, 66, 150, 56, 72, 161, 224, 11, 106, 36, 20, 54, 96, 41, 16, 0, 230, 138,
17, 10, 185, 132, 50, 161, 64, 13, 166, 146, 84, 147, 111, 167, 0, 17, 40, 164, 84, 193,
163, 156, 201, 12, 89, 70, 226, 139, 64, 13, 205, 180, 38, 9, 89, 9, 148, 136, 84, 6, 70,
40, 80, 224, 64, 229, 236, 61, 92, 161, 240, 0, 232, 224, 0, 85, 61, 77, 205, 45, 173, 109,
116, 144, 192, 192, 1, 61, 216, 209, 68, 216, 208, 0, 204, 88, 35, 9, 221, 60, 0, 140, 208,
233, 50, 1, 200, 73, 53, 51, 68, 172, 224, 160, 171, 101, 113, 202, 64, 16, 114, 242, 88,
131, 210, 216, 10, 32, 12, 24, 1, 221, 121, 153, 73, 8, 137, 145, 178, 228, 187, 112, 41,
69, 203, 232, 233, 13, 161, 139, 217, 56, 160, 99, 226, 80, 234, 225, 71, 173, 187, 77,
241, 101, 55, 145, 80, 48, 224, 156, 32, 136, 33, 203, 52, 217, 36, 214, 193, 54, 57, 160,
99, 129, 245, 152, 208, 65, 238, 216, 0, 85, 8, 11, 140, 15, 112, 66, 212, 72, 0, 65, 39,
149, 14, 0, 3, 23, 209, 156, 160, 214, 81, 49, 14, 6, 177, 114, 105, 44, 130, 31, 58, 14,
65, 3, 210, 104, 224, 230, 64, 154, 35, 196, 21, 25, 160, 192, 248, 18, 57, 91, 44, 131, 2,
216, 248, 176, 77, 162, 66, 197, 97, 179, 156, 41, 221, 107, 11, 142, 3, 37, 51, 65, 12,
65, 112, 187, 23, 143, 146, 41, 139, 46, 232, 52, 12, 64, 7, 33, 69, 24, 56, 204, 28, 148,
185, 209, 207, 200, 217, 48, 168, 138, 34, 8, 23, 166, 43, 144, 201, 110, 127, 34, 3, 78,
0, 73, 129, 228, 160, 8, 0, 45, 16, 196, 98, 170, 74, 115, 82, 190, 6, 56, 68, 74, 32, 128,
192, 192, 40, 54, 25, 77, 128, 210, 106, 77, 90, 107, 34, 34, 197, 203, 105, 3, 232, 45,
200, 109, 188, 22, 57, 182, 169, 177, 198, 30, 98, 168, 134, 36, 96, 3, 170, 176, 68, 186,
166, 186, 80, 75, 196, 65, 160, 224, 154, 36, 50, 140, 7, 111, 42, 87, 12, 50, 235, 160,
185, 207, 166, 224, 136, 142, 132, 201, 166, 79, 238, 192, 160, 6, 42, 224, 37, 46, 12, 84,
67, 208, 100, 176, 67, 138, 166, 142, 235, 67, 6, 182, 88, 119, 18, 93, 119, 10, 48, 160,
213, 249, 225, 159, 84, 129, 131, 227, 161, 128, 64, 240, 30, 70, 45, 11, 34, 128, 213,
186, 222, 109, 54, 79, 150, 192, 145, 81, 38, 133, 2, 157, 177, 156, 203, 128, 80, 10, 5,
106, 2, 27, 15, 100, 241, 16, 144, 16, 58, 11, 54, 205, 87, 25, 5, 163, 65, 186, 103, 194,
129, 101, 19, 40, 27, 36, 41, 54, 86, 140, 5, 49, 137, 15, 159, 50, 208, 116, 92, 8, 131,
44, 187, 16, 16, 228, 80, 207, 30, 205, 129, 241, 177, 110, 158, 14, 128, 10, 10, 220, 64,
17, 20, 24, 128, 4, 145, 16, 10, 51, 11, 243, 129, 107, 101, 1, 132, 81, 54, 99, 77, 0,
208, 136, 18, 16, 241, 92, 106, 80, 41, 137, 141, 47, 96, 158, 229, 129, 151, 54, 14, 135,
194, 32, 230, 0, 134, 41, 64, 241, 155, 65, 98, 136, 216, 52, 128, 162, 144, 42, 47, 128,
227, 250, 101, 45, 67, 193, 186, 42, 68, 4, 209, 183, 26, 4, 72, 180, 86, 95, 15, 131, 181,
200, 202, 52, 199, 64, 178, 40, 136, 0, 0,
];
test_dec_bin_compat(
lz_str::decompress_from_uint8_array,
&uint8_array_decompressed
.encode_utf16()
.collect::<Vec<u16>>(),
uint8_array_compressed,
);
eprintln!("UTF16");
let utf16_encoding_decompressed = "During tattooing, ink is injected into the skin, initiating an immune response, and cells called \"macrophages\" move into the area and \"eat up\" the ink. The macrophages carry some of the ink to the body\'s lymph nodes, but some that are filled with ink stay put, embedded in the skin. That\'s what makes the tattoo visible under the skin. Dalhousie Uiversity\'s Alec Falkenham is developing a topical cream that works by targeting the macrophages that have remained at the site of the tattoo. New macrophages move in to consume the previously pigment-filled macrophages and then migrate to the lymph nodes, eventually taking all the dye with them. \"When comparing it to laser-based tattoo removal, in which you see the burns, the scarring, the blisters, in this case, we\'ve designed a drug that doesn\'t really have much off-target effect,\" he said. \"We\'re not targeting any of the normal skin cells, so you won\'t see a lot of inflammation. In fact, based on the process that we\'re actually using, we don\'t think there will be any inflammation at all and it would actually be anti-inflammatory.";
let utf16_encoding_compressed = "\u{0462}\u{5C33}\u{414C}\u{0780}\u{7320}\u{1025}\u{6063}\u{0230}\u{3DBB}\u{51A0}\u{3496}\u{40F6}\u{3C26}\u{3A05}K\u{00C6}\u{01AC}\u{0870}\u{04F4}\u{7AA8}\u{00D0}\u{5731}\u{7DC5}\u{6D24}\u{0441}\u{25AE}\u{0934}\u{1E20}\u{5B71}\u{1070}\u{6CE0}\u{2930}\u{0093}\u{22A4}\u{2177}\u{1863}\u{152A}V\u{4D44}\u{54B3}\u{37F3}\u{4024}\u{2534}\u{456C}\u{0D3C}\u{7344}\u{18D2}\u{4702}\u{45C0}\u{0393}\u{36A4}\u{60B5}\u{486C}\u{5241}\u{282C}\u{4648}\u{2890}\u{1059}\u{3DA7}\u{55EA}\u{0FA0}\u{03C3}\u{4020}\u{555D}\u{2706}\u{4B8B}\u{2DCE}\u{492C}\u{0620}\u{0517}\u{31C2}\u{44F8}\u{6820}\u{3336}\u{0481}\u{1DF3}\u{6024}\u{3363}\u{5284}\u{01E8}\u{24BA}\u{4CF1}\u{15BC}\u{0A2A}\u{5B4B}\u{4749}@\u{7312}\u{2C61}\u{74D6}\u{0164}\u{00E1}\u{402E}\u{7606}\u{32B2}\u{08A9}\u{48F9}\u{394E}\u{6E25}\u{147C}\u{5F67}\u{2456}\u{4337}\u{5958}\u{5051}\u{78B4}\u{1D7C}\u{149A}\u{6DFA}\u{37E5}\u{4A8F}\u{1170}\u{1890}\u{2728}\u{1124}\u{1CD3}\u{26E9}\u{137B}\u{028C}\u{39C0}\u{31E0}\u{7D86}\u{1A28}\u{1F0D}\u{4022}\u{5440}\u{1738}\u{0F90}\u{218A}\u{1220}\u{0844}\u{7970}\u{7020}\u{0C7F}\u{2359}\u{20F6}\u{28B8}\u{43A1}\u{564E}\u{26B2}\u{6430}\u{7D08}\u{1CA2}\u{03F2}\u{3490}\u{39B0}\u{1364}\u{3C61}\u{28ED}\u{0323}\u{7044}\u{397B}\u{1661}\u{40D6}\u{1F36}\u{04FA}\u{1236}\u{15A6}\u{6758}\u{29FD}\u{35A5}\u{63A0}\u{64C6}\u{3430}\u{622B}\u{430C}\u{2F3F}\u{1249}\u{45B7}\u{3A2D}\u{01A8}\u{0092}\u{0A48}\u{6103}\u{1859}\u{14D9}\u{6907}\u{7256}\u{2635}\u{08C2}\u{1060}\u{5EB8}\u{5741}\u{498E}\u{3FB1}\u{00F3}\u{4029}\u{183E}\u{2520}\u{2020}\u{5A41}\u{4482}\u{5545}\u{1CF4}\u{57E0}\u{63A4}\u{2271}\u{0223}\u{01A0}\u{2856}\u{0CC6}\u{6054}\u{4D69}\u{55C6}\u{5931}\u{0B37}\u{16F2}\u{0408}\u{1704}\u{1B8F}\u{02E7}\u{1B8A}\u{4DAE}\u{1899}\u{4571}\u{0644}\u{3021}\u{6ACC}\u{08B7}\u{2A8B}\u{52A2}\u{2F31}\u{0361}\u{60BA}\u{1239}\u{2321}\u{6E05}\u{2590}\u{61B7}\u{2EA2}\u{73BF}\u{2700}\u{4467}\u{2152}\u{34E9}\u{7F0C}\u{0520}\u{18CB}\u{406A}\u{2E2C}\u{2A41}\u{7439}\u{1628}\u{38CA}\u{3497}\u{2D2C}\u{0D8C}\u{5897}\u{094E}\u{5DE2}\u{4634}\u{0D7F}\u{4F2C}\u{7D72}\u{0327}\u{63C1}\u{4040}\u{3C27}\u{48E5}\u{50D2}\u{1426}\u{570B}\u{3CFA}\u{366F}\u{4B80}\u{2474}\u{24F0}\u{5049}\u{6DAC}\u{734E}\u{00C0}\u{0A25}\u{3521}\u{06E3}\u{6CBE}\u{1129}\u{00A1}\u{684C}\u{6DBA}\u{5739}\u{02F1}\u{508E}\u{4D18}\u{2836}\u{28B9}\u{208C}\u{4872}\u{3676}\u{4622}\u{4C82}\u{2213}\u{734D}\u{03C2}\u{7042}\u{0679}\u{3B30}\u{0892}\u{1453}\u{63F9}\u{583F}\u{0DAB}\u{3A98}\u{1D20}\u{0A2A}\u{6E40}\u{0465}\u{0330}i\u{08A0}\u{28EC}\u{1807}\u{018B}\u{32A0}\u{6134}\u{26EC}\u{34F0}\u{06A4}\u{2068}\u{2202}\u{5C8A}\u{2834}\u{6283}\u{260C}\u{0A0E}\u{2C2C}\u{5CF8}\u{1D2F}\u{4240}\u{7320}\u{21AA}\u{283E}\u{19D4}\u{0B34}\u{2380}\u{6921}\u{22B0}\u{1537}\u{6058}\u{7F6C}\u{52F4}\u{1E2D}\u{68C9}\u{0829}\u{51D7}\u{0D22}\u{124D}\u{0AEB}\u{7118}\u{1DCE}\u{2348}\u{69AE}\u{40D2}\u{1464}\u{0020}\u{0020}";
test_dec_bin_compat(
lz_str::decompress_from_utf16,
&utf16_encoding_decompressed
.encode_utf16()
.collect::<Vec<u16>>(),
utf16_encoding_compressed,
);
}
| 443
|
pub fn encode(ch: char) -> Option<u16> {
match ch as u32 {
0x3000 => Some(0x2121u16),
0x3001 => Some(0x2122u16),
0x3002 => Some(0x2123u16),
0xff0c => Some(0x2124u16),
0xff0e => Some(0x2125u16),
0x30fb => Some(0x2126u16),
0xff1a => Some(0x2127u16),
0xff1b => Some(0x2128u16),
0xff1f => Some(0x2129u16),
0xff01 => Some(0x212au16),
0x309b => Some(0x212bu16),
0x309c => Some(0x212cu16),
0x00b4 => Some(0x212du16),
0xff40 => Some(0x212eu16),
0x00a8 => Some(0x212fu16),
0xff3e => Some(0x2130u16),
0xffe3 => Some(0x2131u16),
0xff3f => Some(0x2132u16),
0x30fd => Some(0x2133u16),
0x30fe => Some(0x2134u16),
0x309d => Some(0x2135u16),
0x309e => Some(0x2136u16),
0x3003 => Some(0x2137u16),
0x4edd => Some(0x2138u16),
0x3005 => Some(0x2139u16),
0x3006 => Some(0x213au16),
0x3007 => Some(0x213bu16),
0x30fc => Some(0x213cu16),
0x2015 => Some(0x213du16),
0x2010 => Some(0x213eu16),
0xff0f => Some(0x213fu16),
0x005c => Some(0x2140u16),
0x301c => Some(0x2141u16),
0x2016 => Some(0x2142u16),
0xff5c => Some(0x2143u16),
0x2026 => Some(0x2144u16),
0x2025 => Some(0x2145u16),
0x2018 => Some(0x2146u16),
0x2019 => Some(0x2147u16),
0x201c => Some(0x2148u16),
0x201d => Some(0x2149u16),
0xff08 => Some(0x214au16),
0xff09 => Some(0x214bu16),
0x3014 => Some(0x214cu16),
0x3015 => Some(0x214du16),
0xff3b => Some(0x214eu16),
0xff3d => Some(0x214fu16),
0xff5b => Some(0x2150u16),
0xff5d => Some(0x2151u16),
0x3008 => Some(0x2152u16),
0x3009 => Some(0x2153u16),
0x300a => Some(0x2154u16),
0x300b => Some(0x2155u16),
0x300c => Some(0x2156u16),
0x300d => Some(0x2157u16),
0x300e => Some(0x2158u16),
0x300f => Some(0x2159u16),
0x3010 => Some(0x215au16),
0x3011 => Some(0x215bu16),
0xff0b => Some(0x215cu16),
0x2212 => Some(0x215du16),
0x00b1 => Some(0x215eu16),
0x00d7 => Some(0x215fu16),
0x00f7 => Some(0x2160u16),
0xff1d => Some(0x2161u16),
0x2260 => Some(0x2162u16),
0xff1c => Some(0x2163u16),
0xff1e => Some(0x2164u16),
0x2266 => Some(0x2165u16),
0x2267 => Some(0x2166u16),
0x221e => Some(0x2167u16),
0x2234 => Some(0x2168u16),
0x2642 => Some(0x2169u16),
0x2640 => Some(0x216au16),
0x00b0 => Some(0x216bu16),
0x2032 => Some(0x216cu16),
0x2033 => Some(0x216du16),
0x2103 => Some(0x216eu16),
0xffe5 => Some(0x216fu16),
0xff04 => Some(0x2170u16),
0x00a2 => Some(0x2171u16),
0x00a3 => Some(0x2172u16),
0xff05 => Some(0x2173u16),
0xff03 => Some(0x2174u16),
0xff06 => Some(0x2175u16),
0xff0a => Some(0x2176u16),
0xff20 => Some(0x2177u16),
0x00a7 => Some(0x2178u16),
0x2606 => Some(0x2179u16),
0x2605 => Some(0x217au16),
0x25cb => Some(0x217bu16),
0x25cf => Some(0x217cu16),
0x25ce => Some(0x217du16),
0x25c7 => Some(0x217eu16),
0x25c6 => Some(0x2221u16),
0x25a1 => Some(0x2222u16),
0x25a0 => Some(0x2223u16),
0x25b3 => Some(0x2224u16),
0x25b2 => Some(0x2225u16),
0x25bd => Some(0x2226u16),
0x25bc => Some(0x2227u16),
0x203b => Some(0x2228u16),
0x3012 => Some(0x2229u16),
0x2192 => Some(0x222au16),
0x2190 => Some(0x222bu16),
0x2191 => Some(0x222cu16),
0x2193 => Some(0x222du16),
0x3013 => Some(0x222eu16),
0x2208 => Some(0x223au16),
0x220b => Some(0x223bu16),
0x2286 => Some(0x223cu16),
0x2287 => Some(0x223du16),
0x2282 => Some(0x223eu16),
0x2283 => Some(0x223fu16),
0x222a => Some(0x2240u16),
0x2229 => Some(0x2241u16),
0x2227 => Some(0x224au16),
0x2228 => Some(0x224bu16),
0x00ac => Some(0x224cu16),
0x21d2 => Some(0x224du16),
0x21d4 => Some(0x224eu16),
0x2200 => Some(0x224fu16),
0x2203 => Some(0x2250u16),
0x2220 => Some(0x225cu16),
0x22a5 => Some(0x225du16),
0x2312 => Some(0x225eu16),
0x2202 => Some(0x225fu16),
0x2207 => Some(0x2260u16),
0x2261 => Some(0x2261u16),
0x2252 => Some(0x2262u16),
0x226a => Some(0x2263u16),
0x226b => Some(0x2264u16),
0x221a => Some(0x2265u16),
0x223d => Some(0x2266u16),
0x221d => Some(0x2267u16),
0x2235 => Some(0x2268u16),
0x222b => Some(0x2269u16),
0x222c => Some(0x226au16),
0x212b => Some(0x2272u16),
0x2030 => Some(0x2273u16),
0x266f => Some(0x2274u16),
0x266d => Some(0x2275u16),
0x266a => Some(0x2276u16),
0x2020 => Some(0x2277u16),
0x2021 => Some(0x2278u16),
0x00b6 => Some(0x2279u16),
0x25ef => Some(0x227eu16),
0xff10 => Some(0x2330u16),
0xff11 => Some(0x2331u16),
0xff12 => Some(0x2332u16),
0xff13 => Some(0x2333u16),
0xff14 => Some(0x2334u16),
0xff15 => Some(0x2335u16),
0xff16 => Some(0x2336u16),
0xff17 => Some(0x2337u16),
0xff18 => Some(0x2338u16),
0xff19 => Some(0x2339u16),
0xff21 => Some(0x2341u16),
0xff22 => Some(0x2342u16),
0xff23 => Some(0x2343u16),
0xff24 => Some(0x2344u16),
0xff25 => Some(0x2345u16),
0xff26 => Some(0x2346u16),
0xff27 => Some(0x2347u16),
0xff28 => Some(0x2348u16),
0xff29 => Some(0x2349u16),
0xff2a => Some(0x234au16),
0xff2b => Some(0x234bu16),
0xff2c => Some(0x234cu16),
0xff2d => Some(0x234du16),
0xff2e => Some(0x234eu16),
0xff2f => Some(0x234fu16),
0xff30 => Some(0x2350u16),
0xff31 => Some(0x2351u16),
0xff32 => Some(0x2352u16),
0xff33 => Some(0x2353u16),
0xff34 => Some(0x2354u16),
0xff35 => Some(0x2355u16),
0xff36 => Some(0x2356u16),
0xff37 => Some(0x2357u16),
0xff38 => Some(0x2358u16),
0xff39 => Some(0x2359u16),
0xff3a => Some(0x235au16),
0xff41 => Some(0x2361u16),
0xff42 => Some(0x2362u16),
0xff43 => Some(0x2363u16),
0xff44 => Some(0x2364u16),
0xff45 => Some(0x2365u16),
0xff46 => Some(0x2366u16),
0xff47 => Some(0x2367u16),
0xff48 => Some(0x2368u16),
0xff49 => Some(0x2369u16),
0xff4a => Some(0x236au16),
0xff4b => Some(0x236bu16),
0xff4c => Some(0x236cu16),
0xff4d => Some(0x236du16),
0xff4e => Some(0x236eu16),
0xff4f => Some(0x236fu16),
0xff50 => Some(0x2370u16),
0xff51 => Some(0x2371u16),
0xff52 => Some(0x2372u16),
0xff53 => Some(0x2373u16),
0xff54 => Some(0x2374u16),
0xff55 => Some(0x2375u16),
0xff56 => Some(0x2376u16),
0xff57 => Some(0x2377u16),
0xff58 => Some(0x2378u16),
0xff59 => Some(0x2379u16),
0xff5a => Some(0x237au16),
0x3041 => Some(0x2421u16),
0x3042 => Some(0x2422u16),
0x3043 => Some(0x2423u16),
0x3044 => Some(0x2424u16),
0x3045 => Some(0x2425u16),
0x3046 => Some(0x2426u16),
0x3047 => Some(0x2427u16),
0x3048 => Some(0x2428u16),
0x3049 => Some(0x2429u16),
0x304a => Some(0x242au16),
0x304b => Some(0x242bu16),
0x304c => Some(0x242cu16),
0x304d => Some(0x242du16),
0x304e => Some(0x242eu16),
0x304f => Some(0x242fu16),
0x3050 => Some(0x2430u16),
0x3051 => Some(0x2431u16),
0x3052 => Some(0x2432u16),
0x3053 => Some(0x2433u16),
0x3054 => Some(0x2434u16),
0x3055 => Some(0x2435u16),
0x3056 => Some(0x2436u16),
0x3057 => Some(0x2437u16),
0x3058 => Some(0x2438u16),
0x3059 => Some(0x2439u16),
0x305a => Some(0x243au16),
0x305b => Some(0x243bu16),
0x305c => Some(0x243cu16),
0x305d => Some(0x243du16),
0x305e => Some(0x243eu16),
0x305f => Some(0x243fu16),
0x3060 => Some(0x2440u16),
0x3061 => Some(0x2441u16),
0x3062 => Some(0x2442u16),
0x3063 => Some(0x2443u16),
0x3064 => Some(0x2444u16),
0x3065 => Some(0x2445u16),
0x3066 => Some(0x2446u16),
0x3067 => Some(0x2447u16),
0x3068 => Some(0x2448u16),
0x3069 => Some(0x2449u16),
0x306a => Some(0x244au16),
0x306b => Some(0x244bu16),
0x306c => Some(0x244cu16),
0x306d => Some(0x244du16),
0x306e => Some(0x244eu16),
0x306f => Some(0x244fu16),
0x3070 => Some(0x2450u16),
0x3071 => Some(0x2451u16),
0x3072 => Some(0x2452u16),
0x3073 => Some(0x2453u16),
0x3074 => Some(0x2454u16),
0x3075 => Some(0x2455u16),
0x3076 => Some(0x2456u16),
0x3077 => Some(0x2457u16),
0x3078 => Some(0x2458u16),
0x3079 => Some(0x2459u16),
0x307a => Some(0x245au16),
0x307b => Some(0x245bu16),
0x307c => Some(0x245cu16),
0x307d => Some(0x245du16),
0x307e => Some(0x245eu16),
0x307f => Some(0x245fu16),
0x3080 => Some(0x2460u16),
0x3081 => Some(0x2461u16),
0x3082 => Some(0x2462u16),
0x3083 => Some(0x2463u16),
0x3084 => Some(0x2464u16),
0x3085 => Some(0x2465u16),
0x3086 => Some(0x2466u16),
0x3087 => Some(0x2467u16),
0x3088 => Some(0x2468u16),
0x3089 => Some(0x2469u16),
0x308a => Some(0x246au16),
0x308b => Some(0x246bu16),
0x308c => Some(0x246cu16),
0x308d => Some(0x246du16),
0x308e => Some(0x246eu16),
0x308f => Some(0x246fu16),
0x3090 => Some(0x2470u16),
0x3091 => Some(0x2471u16),
0x3092 => Some(0x2472u16),
0x3093 => Some(0x2473u16),
0x30a1 => Some(0x2521u16),
0x30a2 => Some(0x2522u16),
0x30a3 => Some(0x2523u16),
0x30a4 => Some(0x2524u16),
0x30a5 => Some(0x2525u16),
0x30a6 => Some(0x2526u16),
0x30a7 => Some(0x2527u16),
0x30a8 => Some(0x2528u16),
0x30a9 => Some(0x2529u16),
0x30aa => Some(0x252au16),
0x30ab => Some(0x252bu16),
0x30ac => Some(0x252cu16),
0x30ad => Some(0x252du16),
0x30ae => Some(0x252eu16),
0x30af => Some(0x252fu16),
0x30b0 => Some(0x2530u16),
0x30b1 => Some(0x2531u16),
0x30b2 => Some(0x2532u16),
0x30b3 => Some(0x2533u16),
0x30b4 => Some(0x2534u16),
0x30b5 => Some(0x2535u16),
0x30b6 => Some(0x2536u16),
0x30b7 => Some(0x2537u16),
0x30b8 => Some(0x2538u16),
0x30b9 => Some(0x2539u16),
0x30ba => Some(0x253au16),
0x30bb => Some(0x253bu16),
0x30bc => Some(0x253cu16),
0x30bd => Some(0x253du16),
0x30be => Some(0x253eu16),
0x30bf => Some(0x253fu16),
0x30c0 => Some(0x2540u16),
0x30c1 => Some(0x2541u16),
0x30c2 => Some(0x2542u16),
0x30c3 => Some(0x2543u16),
0x30c4 => Some(0x2544u16),
0x30c5 => Some(0x2545u16),
0x30c6 => Some(0x2546u16),
0x30c7 => Some(0x2547u16),
0x30c8 => Some(0x2548u16),
0x30c9 => Some(0x2549u16),
0x30ca => Some(0x254au16),
0x30cb => Some(0x254bu16),
0x30cc => Some(0x254cu16),
0x30cd => Some(0x254du16),
0x30ce => Some(0x254eu16),
0x30cf => Some(0x254fu16),
0x30d0 => Some(0x2550u16),
0x30d1 => Some(0x2551u16),
0x30d2 => Some(0x2552u16),
0x30d3 => Some(0x2553u16),
0x30d4 => Some(0x2554u16),
0x30d5 => Some(0x2555u16),
0x30d6 => Some(0x2556u16),
0x30d7 => Some(0x2557u16),
0x30d8 => Some(0x2558u16),
0x30d9 => Some(0x2559u16),
0x30da => Some(0x255au16),
0x30db => Some(0x255bu16),
0x30dc => Some(0x255cu16),
0x30dd => Some(0x255du16),
0x30de => Some(0x255eu16),
0x30df => Some(0x255fu16),
0x30e0 => Some(0x2560u16),
0x30e1 => Some(0x2561u16),
0x30e2 => Some(0x2562u16),
0x30e3 => Some(0x2563u16),
0x30e4 => Some(0x2564u16),
0x30e5 => Some(0x2565u16),
0x30e6 => Some(0x2566u16),
0x30e7 => Some(0x2567u16),
0x30e8 => Some(0x2568u16),
0x30e9 => Some(0x2569u16),
0x30ea => Some(0x256au16),
0x30eb => Some(0x256bu16),
0x30ec => Some(0x256cu16),
0x30ed => Some(0x256du16),
0x30ee => Some(0x256eu16),
0x30ef => Some(0x256fu16),
0x30f0 => Some(0x2570u16),
0x30f1 => Some(0x2571u16),
0x30f2 => Some(0x2572u16),
0x30f3 => Some(0x2573u16),
0x30f4 => Some(0x2574u16),
0x30f5 => Some(0x2575u16),
0x30f6 => Some(0x2576u16),
0x0391 => Some(0x2621u16),
0x0392 => Some(0x2622u16),
0x0393 => Some(0x2623u16),
0x0394 => Some(0x2624u16),
0x0395 => Some(0x2625u16),
0x0396 => Some(0x2626u16),
0x0397 => Some(0x2627u16),
0x0398 => Some(0x2628u16),
0x0399 => Some(0x2629u16),
0x039a => Some(0x262au16),
0x039b => Some(0x262bu16),
0x039c => Some(0x262cu16),
0x039d => Some(0x262du16),
0x039e => Some(0x262eu16),
0x039f => Some(0x262fu16),
0x03a0 => Some(0x2630u16),
0x03a1 => Some(0x2631u16),
0x03a3 => Some(0x2632u16),
0x03a4 => Some(0x2633u16),
0x03a5 => Some(0x2634u16),
0x03a6 => Some(0x2635u16),
0x03a7 => Some(0x2636u16),
0x03a8 => Some(0x2637u16),
0x03a9 => Some(0x2638u16),
0x03b1 => Some(0x2641u16),
0x03b2 => Some(0x2642u16),
0x03b3 => Some(0x2643u16),
0x03b4 => Some(0x2644u16),
0x03b5 => Some(0x2645u16),
0x03b6 => Some(0x2646u16),
0x03b7 => Some(0x2647u16),
0x03b8 => Some(0x2648u16),
0x03b9 => Some(0x2649u16),
0x03ba => Some(0x264au16),
0x03bb => Some(0x264bu16),
0x03bc => Some(0x264cu16),
0x03bd => Some(0x264du16),
0x03be => Some(0x264eu16),
0x03bf => Some(0x264fu16),
0x03c0 => Some(0x2650u16),
0x03c1 => Some(0x2651u16),
0x03c3 => Some(0x2652u16),
0x03c4 => Some(0x2653u16),
0x03c5 => Some(0x2654u16),
0x03c6 => Some(0x2655u16),
0x03c7 => Some(0x2656u16),
0x03c8 => Some(0x2657u16),
0x03c9 => Some(0x2658u16),
0x0410 => Some(0x2721u16),
0x0411 => Some(0x2722u16),
0x0412 => Some(0x2723u16),
0x0413 => Some(0x2724u16),
0x0414 => Some(0x2725u16),
0x0415 => Some(0x2726u16),
0x0401 => Some(0x2727u16),
0x0416 => Some(0x2728u16),
0x0417 => Some(0x2729u16),
0x0418 => Some(0x272au16),
0x0419 => Some(0x272bu16),
0x041a => Some(0x272cu16),
0x041b => Some(0x272du16),
0x041c => Some(0x272eu16),
0x041d => Some(0x272fu16),
0x041e => Some(0x2730u16),
0x041f => Some(0x2731u16),
0x0420 => Some(0x2732u16),
0x0421 => Some(0x2733u16),
0x0422 => Some(0x2734u16),
0x0423 => Some(0x2735u16),
0x0424 => Some(0x2736u16),
0x0425 => Some(0x2737u16),
0x0426 => Some(0x2738u16),
0x0427 => Some(0x2739u16),
0x0428 => Some(0x273au16),
0x0429 => Some(0x273bu16),
0x042a => Some(0x273cu16),
0x042b => Some(0x273du16),
0x042c => Some(0x273eu16),
0x042d => Some(0x273fu16),
0x042e => Some(0x2740u16),
0x042f => Some(0x2741u16),
0x0430 => Some(0x2751u16),
0x0431 => Some(0x2752u16),
0x0432 => Some(0x2753u16),
0x0433 => Some(0x2754u16),
0x0434 => Some(0x2755u16),
0x0435 => Some(0x2756u16),
0x0451 => Some(0x2757u16),
0x0436 => Some(0x2758u16),
0x0437 => Some(0x2759u16),
0x0438 => Some(0x275au16),
0x0439 => Some(0x275bu16),
0x043a => Some(0x275cu16),
0x043b => Some(0x275du16),
0x043c => Some(0x275eu16),
0x043d => Some(0x275fu16),
0x043e => Some(0x2760u16),
0x043f => Some(0x2761u16),
0x0440 => Some(0x2762u16),
0x0441 => Some(0x2763u16),
0x0442 => Some(0x2764u16),
0x0443 => Some(0x2765u16),
0x0444 => Some(0x2766u16),
0x0445 => Some(0x2767u16),
0x0446 => Some(0x2768u16),
0x0447 => Some(0x2769u16),
0x0448 => Some(0x276au16),
0x0449 => Some(0x276bu16),
0x044a => Some(0x276cu16),
0x044b => Some(0x276du16),
0x044c => Some(0x276eu16),
0x044d => Some(0x276fu16),
0x044e => Some(0x2770u16),
0x044f => Some(0x2771u16),
0x2500 => Some(0x2821u16),
0x2502 => Some(0x2822u16),
0x250c => Some(0x2823u16),
0x2510 => Some(0x2824u16),
0x2518 => Some(0x2825u16),
0x2514 => Some(0x2826u16),
0x251c => Some(0x2827u16),
0x252c => Some(0x2828u16),
0x2524 => Some(0x2829u16),
0x2534 => Some(0x282au16),
0x253c => Some(0x282bu16),
0x2501 => Some(0x282cu16),
0x2503 => Some(0x282du16),
0x250f => Some(0x282eu16),
0x2513 => Some(0x282fu16),
0x251b => Some(0x2830u16),
0x2517 => Some(0x2831u16),
0x2523 => Some(0x2832u16),
0x2533 => Some(0x2833u16),
0x252b => Some(0x2834u16),
0x253b => Some(0x2835u16),
0x254b => Some(0x2836u16),
0x2520 => Some(0x2837u16),
0x252f => Some(0x2838u16),
0x2528 => Some(0x2839u16),
0x2537 => Some(0x283au16),
0x253f => Some(0x283bu16),
0x251d => Some(0x283cu16),
0x2530 => Some(0x283du16),
0x2525 => Some(0x283eu16),
0x2538 => Some(0x283fu16),
0x2542 => Some(0x2840u16),
0x4e9c => Some(0x3021u16),
0x5516 => Some(0x3022u16),
0x5a03 => Some(0x3023u16),
0x963f => Some(0x3024u16),
0x54c0 => Some(0x3025u16),
0x611b => Some(0x3026u16),
0x6328 => Some(0x3027u16),
0x59f6 => Some(0x3028u16),
0x9022 => Some(0x3029u16),
0x8475 => Some(0x302au16),
0x831c => Some(0x302bu16),
0x7a50 => Some(0x302cu16),
0x60aa => Some(0x302du16),
0x63e1 => Some(0x302eu16),
0x6e25 => Some(0x302fu16),
0x65ed => Some(0x3030u16),
0x8466 => Some(0x3031u16),
0x82a6 => Some(0x3032u16),
0x9bf5 => Some(0x3033u16),
0x6893 => Some(0x3034u16),
0x5727 => Some(0x3035u16),
0x65a1 => Some(0x3036u16),
0x6271 => Some(0x3037u16),
0x5b9b => Some(0x3038u16),
0x59d0 => Some(0x3039u16),
0x867b => Some(0x303au16),
0x98f4 => Some(0x303bu16),
0x7d62 => Some(0x303cu16),
0x7dbe => Some(0x303du16),
0x9b8e => Some(0x303eu16),
0x6216 => Some(0x303fu16),
0x7c9f => Some(0x3040u16),
0x88b7 => Some(0x3041u16),
0x5b89 => Some(0x3042u16),
0x5eb5 => Some(0x3043u16),
0x6309 => Some(0x3044u16),
0x6697 => Some(0x3045u16),
0x6848 => Some(0x3046u16),
0x95c7 => Some(0x3047u16),
0x978d => Some(0x3048u16),
0x674f => Some(0x3049u16),
0x4ee5 => Some(0x304au16),
0x4f0a => Some(0x304bu16),
0x4f4d => Some(0x304cu16),
0x4f9d => Some(0x304du16),
0x5049 => Some(0x304eu16),
0x56f2 => Some(0x304fu16),
0x5937 => Some(0x3050u16),
0x59d4 => Some(0x3051u16),
0x5a01 => Some(0x3052u16),
0x5c09 => Some(0x3053u16),
0x60df => Some(0x3054u16),
0x610f => Some(0x3055u16),
0x6170 => Some(0x3056u16),
0x6613 => Some(0x3057u16),
0x6905 => Some(0x3058u16),
0x70ba => Some(0x3059u16),
0x754f => Some(0x305au16),
0x7570 => Some(0x305bu16),
0x79fb => Some(0x305cu16),
0x7dad => Some(0x305du16),
0x7def => Some(0x305eu16),
0x80c3 => Some(0x305fu16),
0x840e => Some(0x3060u16),
0x8863 => Some(0x3061u16),
0x8b02 => Some(0x3062u16),
0x9055 => Some(0x3063u16),
0x907a => Some(0x3064u16),
0x533b => Some(0x3065u16),
0x4e95 => Some(0x3066u16),
0x4ea5 => Some(0x3067u16),
0x57df => Some(0x3068u16),
0x80b2 => Some(0x3069u16),
0x90c1 => Some(0x306au16),
0x78ef => Some(0x306bu16),
0x4e00 => Some(0x306cu16),
0x58f1 => Some(0x306du16),
0x6ea2 => Some(0x306eu16),
0x9038 => Some(0x306fu16),
0x7a32 => Some(0x3070u16),
0x8328 => Some(0x3071u16),
0x828b => Some(0x3072u16),
0x9c2f => Some(0x3073u16),
0x5141 => Some(0x3074u16),
0x5370 => Some(0x3075u16),
0x54bd => Some(0x3076u16),
0x54e1 => Some(0x3077u16),
0x56e0 => Some(0x3078u16),
0x59fb => Some(0x3079u16),
0x5f15 => Some(0x307au16),
0x98f2 => Some(0x307bu16),
0x6deb => Some(0x307cu16),
0x80e4 => Some(0x307du16),
0x852d => Some(0x307eu16),
0x9662 => Some(0x3121u16),
0x9670 => Some(0x3122u16),
0x96a0 => Some(0x3123u16),
0x97fb => Some(0x3124u16),
0x540b => Some(0x3125u16),
0x53f3 => Some(0x3126u16),
0x5b87 => Some(0x3127u16),
0x70cf => Some(0x3128u16),
0x7fbd => Some(0x3129u16),
0x8fc2 => Some(0x312au16),
0x96e8 => Some(0x312bu16),
0x536f => Some(0x312cu16),
0x9d5c => Some(0x312du16),
0x7aba => Some(0x312eu16),
0x4e11 => Some(0x312fu16),
0x7893 => Some(0x3130u16),
0x81fc => Some(0x3131u16),
0x6e26 => Some(0x3132u16),
0x5618 => Some(0x3133u16),
0x5504 => Some(0x3134u16),
0x6b1d => Some(0x3135u16),
0x851a => Some(0x3136u16),
0x9c3b => Some(0x3137u16),
0x59e5 => Some(0x3138u16),
0x53a9 => Some(0x3139u16),
0x6d66 => Some(0x313au16),
0x74dc => Some(0x313bu16),
0x958f => Some(0x313cu16),
0x5642 => Some(0x313du16),
0x4e91 => Some(0x313eu16),
0x904b => Some(0x313fu16),
0x96f2 => Some(0x3140u16),
0x834f => Some(0x3141u16),
0x990c => Some(0x3142u16),
0x53e1 => Some(0x3143u16),
0x55b6 => Some(0x3144u16),
0x5b30 => Some(0x3145u16),
0x5f71 => Some(0x3146u16),
0x6620 => Some(0x3147u16),
0x66f3 => Some(0x3148u16),
0x6804 => Some(0x3149u16),
0x6c38 => Some(0x314au16),
0x6cf3 => Some(0x314bu16),
0x6d29 => Some(0x314cu16),
0x745b => Some(0x314du16),
0x76c8 => Some(0x314eu16),
0x7a4e => Some(0x314fu16),
0x9834 => Some(0x3150u16),
0x82f1 => Some(0x3151u16),
0x885b => Some(0x3152u16),
0x8a60 => Some(0x3153u16),
0x92ed => Some(0x3154u16),
0x6db2 => Some(0x3155u16),
0x75ab => Some(0x3156u16),
0x76ca => Some(0x3157u16),
0x99c5 => Some(0x3158u16),
0x60a6 => Some(0x3159u16),
0x8b01 => Some(0x315au16),
0x8d8a => Some(0x315bu16),
0x95b2 => Some(0x315cu16),
0x698e => Some(0x315du16),
0x53ad => Some(0x315eu16),
0x5186 => Some(0x315fu16),
0x5712 => Some(0x3160u16),
0x5830 => Some(0x3161u16),
0x5944 => Some(0x3162u16),
0x5bb4 => Some(0x3163u16),
0x5ef6 => Some(0x3164u16),
0x6028 => Some(0x3165u16),
0x63a9 => Some(0x3166u16),
0x63f4 => Some(0x3167u16),
0x6cbf => Some(0x3168u16),
0x6f14 => Some(0x3169u16),
0x708e => Some(0x316au16),
0x7114 => Some(0x316bu16),
0x7159 => Some(0x316cu16),
0x71d5 => Some(0x316du16),
0x733f => Some(0x316eu16),
0x7e01 => Some(0x316fu16),
0x8276 => Some(0x3170u16),
0x82d1 => Some(0x3171u16),
0x8597 => Some(0x3172u16),
0x9060 => Some(0x3173u16),
0x925b => Some(0x3174u16),
0x9d1b => Some(0x3175u16),
0x5869 => Some(0x3176u16),
0x65bc => Some(0x3177u16),
0x6c5a => Some(0x3178u16),
0x7525 => Some(0x3179u16),
0x51f9 => Some(0x317au16),
0x592e => Some(0x317bu16),
0x5965 => Some(0x317cu16),
0x5f80 => Some(0x317du16),
0x5fdc => Some(0x317eu16),
0x62bc => Some(0x3221u16),
0x65fa => Some(0x3222u16),
0x6a2a => Some(0x3223u16),
0x6b27 => Some(0x3224u16),
0x6bb4 => Some(0x3225u16),
0x738b => Some(0x3226u16),
0x7fc1 => Some(0x3227u16),
0x8956 => Some(0x3228u16),
0x9d2c => Some(0x3229u16),
0x9d0e => Some(0x322au16),
0x9ec4 => Some(0x322bu16),
0x5ca1 => Some(0x322cu16),
0x6c96 => Some(0x322du16),
0x837b => Some(0x322eu16),
0x5104 => Some(0x322fu16),
0x5c4b => Some(0x3230u16),
0x61b6 => Some(0x3231u16),
0x81c6 => Some(0x3232u16),
0x6876 => Some(0x3233u16),
0x7261 => Some(0x3234u16),
0x4e59 => Some(0x3235u16),
0x4ffa => Some(0x3236u16),
0x5378 => Some(0x3237u16),
0x6069 => Some(0x3238u16),
0x6e29 => Some(0x3239u16),
0x7a4f => Some(0x323au16),
0x97f3 => Some(0x323bu16),
0x4e0b => Some(0x323cu16),
0x5316 => Some(0x323du16),
0x4eee => Some(0x323eu16),
0x4f55 => Some(0x323fu16),
0x4f3d => Some(0x3240u16),
0x4fa1 => Some(0x3241u16),
0x4f73 => Some(0x3242u16),
0x52a0 => Some(0x3243u16),
0x53ef => Some(0x3244u16),
0x5609 => Some(0x3245u16),
0x590f => Some(0x3246u16),
0x5ac1 => Some(0x3247u16),
0x5bb6 => Some(0x3248u16),
0x5be1 => Some(0x3249u16),
0x79d1 => Some(0x324au16),
0x6687 => Some(0x324bu16),
0x679c => Some(0x324cu16),
0x67b6 => Some(0x324du16),
0x6b4c => Some(0x324eu16),
0x6cb3 => Some(0x324fu16),
0x706b => Some(0x3250u16),
0x73c2 => Some(0x3251u16),
0x798d => Some(0x3252u16),
0x79be => Some(0x3253u16),
0x7a3c => Some(0x3254u16),
0x7b87 => Some(0x3255u16),
0x82b1 => Some(0x3256u16),
0x82db => Some(0x3257u16),
0x8304 => Some(0x3258u16),
0x8377 => Some(0x3259u16),
0x83ef => Some(0x325au16),
0x83d3 => Some(0x325bu16),
0x8766 => Some(0x325cu16),
0x8ab2 => Some(0x325du16),
0x5629 => Some(0x325eu16),
0x8ca8 => Some(0x325fu16),
0x8fe6 => Some(0x3260u16),
0x904e => Some(0x3261u16),
0x971e => Some(0x3262u16),
0x868a => Some(0x3263u16),
0x4fc4 => Some(0x3264u16),
0x5ce8 => Some(0x3265u16),
0x6211 => Some(0x3266u16),
0x7259 => Some(0x3267u16),
0x753b => Some(0x3268u16),
0x81e5 => Some(0x3269u16),
0x82bd => Some(0x326au16),
0x86fe => Some(0x326bu16),
0x8cc0 => Some(0x326cu16),
0x96c5 => Some(0x326du16),
0x9913 => Some(0x326eu16),
0x99d5 => Some(0x326fu16),
0x4ecb => Some(0x3270u16),
0x4f1a => Some(0x3271u16),
0x89e3 => Some(0x3272u16),
0x56de => Some(0x3273u16),
0x584a => Some(0x3274u16),
0x58ca => Some(0x3275u16),
0x5efb => Some(0x3276u16),
0x5feb => Some(0x3277u16),
0x602a => Some(0x3278u16),
0x6094 => Some(0x3279u16),
0x6062 => Some(0x327au16),
0x61d0 => Some(0x327bu16),
0x6212 => Some(0x327cu16),
0x62d0 => Some(0x327du16),
0x6539 => Some(0x327eu16),
0x9b41 => Some(0x3321u16),
0x6666 => Some(0x3322u16),
0x68b0 => Some(0x3323u16),
0x6d77 => Some(0x3324u16),
0x7070 => Some(0x3325u16),
0x754c => Some(0x3326u16),
0x7686 => Some(0x3327u16),
0x7d75 => Some(0x3328u16),
0x82a5 => Some(0x3329u16),
0x87f9 => Some(0x332au16),
0x958b => Some(0x332bu16),
0x968e => Some(0x332cu16),
0x8c9d => Some(0x332du16),
0x51f1 => Some(0x332eu16),
0x52be => Some(0x332fu16),
0x5916 => Some(0x3330u16),
0x54b3 => Some(0x3331u16),
0x5bb3 => Some(0x3332u16),
0x5d16 => Some(0x3333u16),
0x6168 => Some(0x3334u16),
0x6982 => Some(0x3335u16),
0x6daf => Some(0x3336u16),
0x788d => Some(0x3337u16),
0x84cb => Some(0x3338u16),
0x8857 => Some(0x3339u16),
0x8a72 => Some(0x333au16),
0x93a7 => Some(0x333bu16),
0x9ab8 => Some(0x333cu16),
0x6d6c => Some(0x333du16),
0x99a8 => Some(0x333eu16),
0x86d9 => Some(0x333fu16),
0x57a3 => Some(0x3340u16),
0x67ff => Some(0x3341u16),
0x86ce => Some(0x3342u16),
0x920e => Some(0x3343u16),
0x5283 => Some(0x3344u16),
0x5687 => Some(0x3345u16),
0x5404 => Some(0x3346u16),
0x5ed3 => Some(0x3347u16),
0x62e1 => Some(0x3348u16),
0x64b9 => Some(0x3349u16),
0x683c => Some(0x334au16),
0x6838 => Some(0x334bu16),
0x6bbb => Some(0x334cu16),
0x7372 => Some(0x334du16),
0x78ba => Some(0x334eu16),
0x7a6b => Some(0x334fu16),
0x899a => Some(0x3350u16),
0x89d2 => Some(0x3351u16),
0x8d6b => Some(0x3352u16),
0x8f03 => Some(0x3353u16),
0x90ed => Some(0x3354u16),
0x95a3 => Some(0x3355u16),
0x9694 => Some(0x3356u16),
0x9769 => Some(0x3357u16),
0x5b66 => Some(0x3358u16),
0x5cb3 => Some(0x3359u16),
0x697d => Some(0x335au16),
0x984d => Some(0x335bu16),
0x984e => Some(0x335cu16),
0x639b => Some(0x335du16),
0x7b20 => Some(0x335eu16),
0x6a2b => Some(0x335fu16),
0x6a7f => Some(0x3360u16),
0x68b6 => Some(0x3361u16),
0x9c0d => Some(0x3362u16),
0x6f5f => Some(0x3363u16),
0x5272 => Some(0x3364u16),
0x559d => Some(0x3365u16),
0x6070 => Some(0x3366u16),
0x62ec => Some(0x3367u16),
0x6d3b => Some(0x3368u16),
0x6e07 => Some(0x3369u16),
0x6ed1 => Some(0x336au16),
0x845b => Some(0x336bu16),
0x8910 => Some(0x336cu16),
0x8f44 => Some(0x336du16),
0x4e14 => Some(0x336eu16),
0x9c39 => Some(0x336fu16),
0x53f6 => Some(0x3370u16),
0x691b => Some(0x3371u16),
0x6a3a => Some(0x3372u16),
0x9784 => Some(0x3373u16),
0x682a => Some(0x3374u16),
0x515c => Some(0x3375u16),
0x7ac3 => Some(0x3376u16),
0x84b2 => Some(0x3377u16),
0x91dc => Some(0x3378u16),
0x938c => Some(0x3379u16),
0x565b => Some(0x337au16),
0x9d28 => Some(0x337bu16),
0x6822 => Some(0x337cu16),
0x8305 => Some(0x337du16),
0x8431 => Some(0x337eu16),
0x7ca5 => Some(0x3421u16),
0x5208 => Some(0x3422u16),
0x82c5 => Some(0x3423u16),
0x74e6 => Some(0x3424u16),
0x4e7e => Some(0x3425u16),
0x4f83 => Some(0x3426u16),
0x51a0 => Some(0x3427u16),
0x5bd2 => Some(0x3428u16),
0x520a => Some(0x3429u16),
0x52d8 => Some(0x342au16),
0x52e7 => Some(0x342bu16),
0x5dfb => Some(0x342cu16),
0x559a => Some(0x342du16),
0x582a => Some(0x342eu16),
0x59e6 => Some(0x342fu16),
0x5b8c => Some(0x3430u16),
0x5b98 => Some(0x3431u16),
0x5bdb => Some(0x3432u16),
0x5e72 => Some(0x3433u16),
0x5e79 => Some(0x3434u16),
0x60a3 => Some(0x3435u16),
0x611f => Some(0x3436u16),
0x6163 => Some(0x3437u16),
0x61be => Some(0x3438u16),
0x63db => Some(0x3439u16),
0x6562 => Some(0x343au16),
0x67d1 => Some(0x343bu16),
0x6853 => Some(0x343cu16),
0x68fa => Some(0x343du16),
0x6b3e => Some(0x343eu16),
0x6b53 => Some(0x343fu16),
0x6c57 => Some(0x3440u16),
0x6f22 => Some(0x3441u16),
0x6f97 => Some(0x3442u16),
0x6f45 => Some(0x3443u16),
0x74b0 => Some(0x3444u16),
0x7518 => Some(0x3445u16),
0x76e3 => Some(0x3446u16),
0x770b => Some(0x3447u16),
0x7aff => Some(0x3448u16),
0x7ba1 => Some(0x3449u16),
0x7c21 => Some(0x344au16),
0x7de9 => Some(0x344bu16),
0x7f36 => Some(0x344cu16),
0x7ff0 => Some(0x344du16),
0x809d => Some(0x344eu16),
0x8266 => Some(0x344fu16),
0x839e => Some(0x3450u16),
0x89b3 => Some(0x3451u16),
0x8acc => Some(0x3452u16),
0x8cab => Some(0x3453u16),
0x9084 => Some(0x3454u16),
0x9451 => Some(0x3455u16),
0x9593 => Some(0x3456u16),
0x9591 => Some(0x3457u16),
0x95a2 => Some(0x3458u16),
0x9665 => Some(0x3459u16),
0x97d3 => Some(0x345au16),
0x9928 => Some(0x345bu16),
0x8218 => Some(0x345cu16),
0x4e38 => Some(0x345du16),
0x542b => Some(0x345eu16),
0x5cb8 => Some(0x345fu16),
0x5dcc => Some(0x3460u16),
0x73a9 => Some(0x3461u16),
0x764c => Some(0x3462u16),
0x773c => Some(0x3463u16),
0x5ca9 => Some(0x3464u16),
0x7feb => Some(0x3465u16),
0x8d0b => Some(0x3466u16),
0x96c1 => Some(0x3467u16),
0x9811 => Some(0x3468u16),
0x9854 => Some(0x3469u16),
0x9858 => Some(0x346au16),
0x4f01 => Some(0x346bu16),
0x4f0e => Some(0x346cu16),
0x5371 => Some(0x346du16),
0x559c => Some(0x346eu16),
0x5668 => Some(0x346fu16),
0x57fa => Some(0x3470u16),
0x5947 => Some(0x3471u16),
0x5b09 => Some(0x3472u16),
0x5bc4 => Some(0x3473u16),
0x5c90 => Some(0x3474u16),
0x5e0c => Some(0x3475u16),
0x5e7e => Some(0x3476u16),
0x5fcc => Some(0x3477u16),
0x63ee => Some(0x3478u16),
0x673a => Some(0x3479u16),
0x65d7 => Some(0x347au16),
0x65e2 => Some(0x347bu16),
0x671f => Some(0x347cu16),
0x68cb => Some(0x347du16),
0x68c4 => Some(0x347eu16),
0x6a5f => Some(0x3521u16),
0x5e30 => Some(0x3522u16),
0x6bc5 => Some(0x3523u16),
0x6c17 => Some(0x3524u16),
0x6c7d => Some(0x3525u16),
0x757f => Some(0x3526u16),
0x7948 => Some(0x3527u16),
0x5b63 => Some(0x3528u16),
0x7a00 => Some(0x3529u16),
0x7d00 => Some(0x352au16),
0x5fbd => Some(0x352bu16),
0x898f => Some(0x352cu16),
0x8a18 => Some(0x352du16),
0x8cb4 => Some(0x352eu16),
0x8d77 => Some(0x352fu16),
0x8ecc => Some(0x3530u16),
0x8f1d => Some(0x3531u16),
0x98e2 => Some(0x3532u16),
0x9a0e => Some(0x3533u16),
0x9b3c => Some(0x3534u16),
0x4e80 => Some(0x3535u16),
0x507d => Some(0x3536u16),
0x5100 => Some(0x3537u16),
0x5993 => Some(0x3538u16),
0x5b9c => Some(0x3539u16),
0x622f => Some(0x353au16),
0x6280 => Some(0x353bu16),
0x64ec => Some(0x353cu16),
0x6b3a => Some(0x353du16),
0x72a0 => Some(0x353eu16),
0x7591 => Some(0x353fu16),
0x7947 => Some(0x3540u16),
0x7fa9 => Some(0x3541u16),
0x87fb => Some(0x3542u16),
0x8abc => Some(0x3543u16),
0x8b70 => Some(0x3544u16),
0x63ac => Some(0x3545u16),
0x83ca => Some(0x3546u16),
0x97a0 => Some(0x3547u16),
0x5409 => Some(0x3548u16),
0x5403 => Some(0x3549u16),
0x55ab => Some(0x354au16),
0x6854 => Some(0x354bu16),
0x6a58 => Some(0x354cu16),
0x8a70 => Some(0x354du16),
0x7827 => Some(0x354eu16),
0x6775 => Some(0x354fu16),
0x9ecd => Some(0x3550u16),
0x5374 => Some(0x3551u16),
0x5ba2 => Some(0x3552u16),
0x811a => Some(0x3553u16),
0x8650 => Some(0x3554u16),
0x9006 => Some(0x3555u16),
0x4e18 => Some(0x3556u16),
0x4e45 => Some(0x3557u16),
0x4ec7 => Some(0x3558u16),
0x4f11 => Some(0x3559u16),
0x53ca => Some(0x355au16),
0x5438 => Some(0x355bu16),
0x5bae => Some(0x355cu16),
0x5f13 => Some(0x355du16),
0x6025 => Some(0x355eu16),
0x6551 => Some(0x355fu16),
0x673d => Some(0x3560u16),
0x6c42 => Some(0x3561u16),
0x6c72 => Some(0x3562u16),
0x6ce3 => Some(0x3563u16),
0x7078 => Some(0x3564u16),
0x7403 => Some(0x3565u16),
0x7a76 => Some(0x3566u16),
0x7aae => Some(0x3567u16),
0x7b08 => Some(0x3568u16),
0x7d1a => Some(0x3569u16),
0x7cfe => Some(0x356au16),
0x7d66 => Some(0x356bu16),
0x65e7 => Some(0x356cu16),
0x725b => Some(0x356du16),
0x53bb => Some(0x356eu16),
0x5c45 => Some(0x356fu16),
0x5de8 => Some(0x3570u16),
0x62d2 => Some(0x3571u16),
0x62e0 => Some(0x3572u16),
0x6319 => Some(0x3573u16),
0x6e20 => Some(0x3574u16),
0x865a => Some(0x3575u16),
0x8a31 => Some(0x3576u16),
0x8ddd => Some(0x3577u16),
0x92f8 => Some(0x3578u16),
0x6f01 => Some(0x3579u16),
0x79a6 => Some(0x357au16),
0x9b5a => Some(0x357bu16),
0x4ea8 => Some(0x357cu16),
0x4eab => Some(0x357du16),
0x4eac => Some(0x357eu16),
0x4f9b => Some(0x3621u16),
0x4fa0 => Some(0x3622u16),
0x50d1 => Some(0x3623u16),
0x5147 => Some(0x3624u16),
0x7af6 => Some(0x3625u16),
0x5171 => Some(0x3626u16),
0x51f6 => Some(0x3627u16),
0x5354 => Some(0x3628u16),
0x5321 => Some(0x3629u16),
0x537f => Some(0x362au16),
0x53eb => Some(0x362bu16),
0x55ac => Some(0x362cu16),
0x5883 => Some(0x362du16),
0x5ce1 => Some(0x362eu16),
0x5f37 => Some(0x362fu16),
0x5f4a => Some(0x3630u16),
0x602f => Some(0x3631u16),
0x6050 => Some(0x3632u16),
0x606d => Some(0x3633u16),
0x631f => Some(0x3634u16),
0x6559 => Some(0x3635u16),
0x6a4b => Some(0x3636u16),
0x6cc1 => Some(0x3637u16),
0x72c2 => Some(0x3638u16),
0x72ed => Some(0x3639u16),
0x77ef => Some(0x363au16),
0x80f8 => Some(0x363bu16),
0x8105 => Some(0x363cu16),
0x8208 => Some(0x363du16),
0x854e => Some(0x363eu16),
0x90f7 => Some(0x363fu16),
0x93e1 => Some(0x3640u16),
0x97ff => Some(0x3641u16),
0x9957 => Some(0x3642u16),
0x9a5a => Some(0x3643u16),
0x4ef0 => Some(0x3644u16),
0x51dd => Some(0x3645u16),
0x5c2d => Some(0x3646u16),
0x6681 => Some(0x3647u16),
0x696d => Some(0x3648u16),
0x5c40 => Some(0x3649u16),
0x66f2 => Some(0x364au16),
0x6975 => Some(0x364bu16),
0x7389 => Some(0x364cu16),
0x6850 => Some(0x364du16),
0x7c81 => Some(0x364eu16),
0x50c5 => Some(0x364fu16),
0x52e4 => Some(0x3650u16),
0x5747 => Some(0x3651u16),
0x5dfe => Some(0x3652u16),
0x9326 => Some(0x3653u16),
0x65a4 => Some(0x3654u16),
0x6b23 => Some(0x3655u16),
0x6b3d => Some(0x3656u16),
0x7434 => Some(0x3657u16),
0x7981 => Some(0x3658u16),
0x79bd => Some(0x3659u16),
0x7b4b => Some(0x365au16),
0x7dca => Some(0x365bu16),
0x82b9 => Some(0x365cu16),
0x83cc => Some(0x365du16),
0x887f => Some(0x365eu16),
0x895f => Some(0x365fu16),
0x8b39 => Some(0x3660u16),
0x8fd1 => Some(0x3661u16),
0x91d1 => Some(0x3662u16),
0x541f => Some(0x3663u16),
0x9280 => Some(0x3664u16),
0x4e5d => Some(0x3665u16),
0x5036 => Some(0x3666u16),
0x53e5 => Some(0x3667u16),
0x533a => Some(0x3668u16),
0x72d7 => Some(0x3669u16),
0x7396 => Some(0x366au16),
0x77e9 => Some(0x366bu16),
0x82e6 => Some(0x366cu16),
0x8eaf => Some(0x366du16),
0x99c6 => Some(0x366eu16),
0x99c8 => Some(0x366fu16),
0x99d2 => Some(0x3670u16),
0x5177 => Some(0x3671u16),
0x611a => Some(0x3672u16),
0x865e => Some(0x3673u16),
0x55b0 => Some(0x3674u16),
0x7a7a => Some(0x3675u16),
0x5076 => Some(0x3676u16),
0x5bd3 => Some(0x3677u16),
0x9047 => Some(0x3678u16),
0x9685 => Some(0x3679u16),
0x4e32 => Some(0x367au16),
0x6adb => Some(0x367bu16),
0x91e7 => Some(0x367cu16),
0x5c51 => Some(0x367du16),
0x5c48 => Some(0x367eu16),
0x6398 => Some(0x3721u16),
0x7a9f => Some(0x3722u16),
0x6c93 => Some(0x3723u16),
0x9774 => Some(0x3724u16),
0x8f61 => Some(0x3725u16),
0x7aaa => Some(0x3726u16),
0x718a => Some(0x3727u16),
0x9688 => Some(0x3728u16),
0x7c82 => Some(0x3729u16),
0x6817 => Some(0x372au16),
0x7e70 => Some(0x372bu16),
0x6851 => Some(0x372cu16),
0x936c => Some(0x372du16),
0x52f2 => Some(0x372eu16),
0x541b => Some(0x372fu16),
0x85ab => Some(0x3730u16),
0x8a13 => Some(0x3731u16),
0x7fa4 => Some(0x3732u16),
0x8ecd => Some(0x3733u16),
0x90e1 => Some(0x3734u16),
0x5366 => Some(0x3735u16),
0x8888 => Some(0x3736u16),
0x7941 => Some(0x3737u16),
0x4fc2 => Some(0x3738u16),
0x50be => Some(0x3739u16),
0x5211 => Some(0x373au16),
0x5144 => Some(0x373bu16),
0x5553 => Some(0x373cu16),
0x572d => Some(0x373du16),
0x73ea => Some(0x373eu16),
0x578b => Some(0x373fu16),
0x5951 => Some(0x3740u16),
0x5f62 => Some(0x3741u16),
0x5f84 => Some(0x3742u16),
0x6075 => Some(0x3743u16),
0x6176 => Some(0x3744u16),
0x6167 => Some(0x3745u16),
0x61a9 => Some(0x3746u16),
0x63b2 => Some(0x3747u16),
0x643a => Some(0x3748u16),
0x656c => Some(0x3749u16),
0x666f => Some(0x374au16),
0x6842 => Some(0x374bu16),
0x6e13 => Some(0x374cu16),
0x7566 => Some(0x374du16),
0x7a3d => Some(0x374eu16),
0x7cfb => Some(0x374fu16),
0x7d4c => Some(0x3750u16),
0x7d99 => Some(0x3751u16),
0x7e4b => Some(0x3752u16),
0x7f6b => Some(0x3753u16),
0x830e => Some(0x3754u16),
0x834a => Some(0x3755u16),
0x86cd => Some(0x3756u16),
0x8a08 => Some(0x3757u16),
0x8a63 => Some(0x3758u16),
0x8b66 => Some(0x3759u16),
0x8efd => Some(0x375au16),
0x981a => Some(0x375bu16),
0x9d8f => Some(0x375cu16),
0x82b8 => Some(0x375du16),
0x8fce => Some(0x375eu16),
0x9be8 => Some(0x375fu16),
0x5287 => Some(0x3760u16),
0x621f => Some(0x3761u16),
0x6483 => Some(0x3762u16),
0x6fc0 => Some(0x3763u16),
0x9699 => Some(0x3764u16),
0x6841 => Some(0x3765u16),
0x5091 => Some(0x3766u16),
0x6b20 => Some(0x3767u16),
0x6c7a => Some(0x3768u16),
0x6f54 => Some(0x3769u16),
0x7a74 => Some(0x376au16),
0x7d50 => Some(0x376bu16),
0x8840 => Some(0x376cu16),
0x8a23 => Some(0x376du16),
0x6708 => Some(0x376eu16),
0x4ef6 => Some(0x376fu16),
0x5039 => Some(0x3770u16),
0x5026 => Some(0x3771u16),
0x5065 => Some(0x3772u16),
0x517c => Some(0x3773u16),
0x5238 => Some(0x3774u16),
0x5263 => Some(0x3775u16),
0x55a7 => Some(0x3776u16),
0x570f => Some(0x3777u16),
0x5805 => Some(0x3778u16),
0x5acc => Some(0x3779u16),
0x5efa => Some(0x377au16),
0x61b2 => Some(0x377bu16),
0x61f8 => Some(0x377cu16),
0x62f3 => Some(0x377du16),
0x6372 => Some(0x377eu16),
0x691c => Some(0x3821u16),
0x6a29 => Some(0x3822u16),
0x727d => Some(0x3823u16),
0x72ac => Some(0x3824u16),
0x732e => Some(0x3825u16),
0x7814 => Some(0x3826u16),
0x786f => Some(0x3827u16),
0x7d79 => Some(0x3828u16),
0x770c => Some(0x3829u16),
0x80a9 => Some(0x382au16),
0x898b => Some(0x382bu16),
0x8b19 => Some(0x382cu16),
0x8ce2 => Some(0x382du16),
0x8ed2 => Some(0x382eu16),
0x9063 => Some(0x382fu16),
0x9375 => Some(0x3830u16),
0x967a => Some(0x3831u16),
0x9855 => Some(0x3832u16),
0x9a13 => Some(0x3833u16),
0x9e78 => Some(0x3834u16),
0x5143 => Some(0x3835u16),
0x539f => Some(0x3836u16),
0x53b3 => Some(0x3837u16),
0x5e7b => Some(0x3838u16),
0x5f26 => Some(0x3839u16),
0x6e1b => Some(0x383au16),
0x6e90 => Some(0x383bu16),
0x7384 => Some(0x383cu16),
0x73fe => Some(0x383du16),
0x7d43 => Some(0x383eu16),
0x8237 => Some(0x383fu16),
0x8a00 => Some(0x3840u16),
0x8afa => Some(0x3841u16),
0x9650 => Some(0x3842u16),
0x4e4e => Some(0x3843u16),
0x500b => Some(0x3844u16),
0x53e4 => Some(0x3845u16),
0x547c => Some(0x3846u16),
0x56fa => Some(0x3847u16),
0x59d1 => Some(0x3848u16),
0x5b64 => Some(0x3849u16),
0x5df1 => Some(0x384au16),
0x5eab => Some(0x384bu16),
0x5f27 => Some(0x384cu16),
0x6238 => Some(0x384du16),
0x6545 => Some(0x384eu16),
0x67af => Some(0x384fu16),
0x6e56 => Some(0x3850u16),
0x72d0 => Some(0x3851u16),
0x7cca => Some(0x3852u16),
0x88b4 => Some(0x3853u16),
0x80a1 => Some(0x3854u16),
0x80e1 => Some(0x3855u16),
0x83f0 => Some(0x3856u16),
0x864e => Some(0x3857u16),
0x8a87 => Some(0x3858u16),
0x8de8 => Some(0x3859u16),
0x9237 => Some(0x385au16),
0x96c7 => Some(0x385bu16),
0x9867 => Some(0x385cu16),
0x9f13 => Some(0x385du16),
0x4e94 => Some(0x385eu16),
0x4e92 => Some(0x385fu16),
0x4f0d => Some(0x3860u16),
0x5348 => Some(0x3861u16),
0x5449 => Some(0x3862u16),
0x543e => Some(0x3863u16),
0x5a2f => Some(0x3864u16),
0x5f8c => Some(0x3865u16),
0x5fa1 => Some(0x3866u16),
0x609f => Some(0x3867u16),
0x68a7 => Some(0x3868u16),
0x6a8e => Some(0x3869u16),
0x745a => Some(0x386au16),
0x7881 => Some(0x386bu16),
0x8a9e => Some(0x386cu16),
0x8aa4 => Some(0x386du16),
0x8b77 => Some(0x386eu16),
0x9190 => Some(0x386fu16),
0x4e5e => Some(0x3870u16),
0x9bc9 => Some(0x3871u16),
0x4ea4 => Some(0x3872u16),
0x4f7c => Some(0x3873u16),
0x4faf => Some(0x3874u16),
0x5019 => Some(0x3875u16),
0x5016 => Some(0x3876u16),
0x5149 => Some(0x3877u16),
0x516c => Some(0x3878u16),
0x529f => Some(0x3879u16),
0x52b9 => Some(0x387au16),
0x52fe => Some(0x387bu16),
0x539a => Some(0x387cu16),
0x53e3 => Some(0x387du16),
0x5411 => Some(0x387eu16),
0x540e => Some(0x3921u16),
0x5589 => Some(0x3922u16),
0x5751 => Some(0x3923u16),
0x57a2 => Some(0x3924u16),
0x597d => Some(0x3925u16),
0x5b54 => Some(0x3926u16),
0x5b5d => Some(0x3927u16),
0x5b8f => Some(0x3928u16),
0x5de5 => Some(0x3929u16),
0x5de7 => Some(0x392au16),
0x5df7 => Some(0x392bu16),
0x5e78 => Some(0x392cu16),
0x5e83 => Some(0x392du16),
0x5e9a => Some(0x392eu16),
0x5eb7 => Some(0x392fu16),
0x5f18 => Some(0x3930u16),
0x6052 => Some(0x3931u16),
0x614c => Some(0x3932u16),
0x6297 => Some(0x3933u16),
0x62d8 => Some(0x3934u16),
0x63a7 => Some(0x3935u16),
0x653b => Some(0x3936u16),
0x6602 => Some(0x3937u16),
0x6643 => Some(0x3938u16),
0x66f4 => Some(0x3939u16),
0x676d => Some(0x393au16),
0x6821 => Some(0x393bu16),
0x6897 => Some(0x393cu16),
0x69cb => Some(0x393du16),
0x6c5f => Some(0x393eu16),
0x6d2a => Some(0x393fu16),
0x6d69 => Some(0x3940u16),
0x6e2f => Some(0x3941u16),
0x6e9d => Some(0x3942u16),
0x7532 => Some(0x3943u16),
0x7687 => Some(0x3944u16),
0x786c => Some(0x3945u16),
0x7a3f => Some(0x3946u16),
0x7ce0 => Some(0x3947u16),
0x7d05 => Some(0x3948u16),
0x7d18 => Some(0x3949u16),
0x7d5e => Some(0x394au16),
0x7db1 => Some(0x394bu16),
0x8015 => Some(0x394cu16),
0x8003 => Some(0x394du16),
0x80af => Some(0x394eu16),
0x80b1 => Some(0x394fu16),
0x8154 => Some(0x3950u16),
0x818f => Some(0x3951u16),
0x822a => Some(0x3952u16),
0x8352 => Some(0x3953u16),
0x884c => Some(0x3954u16),
0x8861 => Some(0x3955u16),
0x8b1b => Some(0x3956u16),
0x8ca2 => Some(0x3957u16),
0x8cfc => Some(0x3958u16),
0x90ca => Some(0x3959u16),
0x9175 => Some(0x395au16),
0x9271 => Some(0x395bu16),
0x783f => Some(0x395cu16),
0x92fc => Some(0x395du16),
0x95a4 => Some(0x395eu16),
0x964d => Some(0x395fu16),
0x9805 => Some(0x3960u16),
0x9999 => Some(0x3961u16),
0x9ad8 => Some(0x3962u16),
0x9d3b => Some(0x3963u16),
0x525b => Some(0x3964u16),
0x52ab => Some(0x3965u16),
0x53f7 => Some(0x3966u16),
0x5408 => Some(0x3967u16),
0x58d5 => Some(0x3968u16),
0x62f7 => Some(0x3969u16),
0x6fe0 => Some(0x396au16),
0x8c6a => Some(0x396bu16),
0x8f5f => Some(0x396cu16),
0x9eb9 => Some(0x396du16),
0x514b => Some(0x396eu16),
0x523b => Some(0x396fu16),
0x544a => Some(0x3970u16),
0x56fd => Some(0x3971u16),
0x7a40 => Some(0x3972u16),
0x9177 => Some(0x3973u16),
0x9d60 => Some(0x3974u16),
0x9ed2 => Some(0x3975u16),
0x7344 => Some(0x3976u16),
0x6f09 => Some(0x3977u16),
0x8170 => Some(0x3978u16),
0x7511 => Some(0x3979u16),
0x5ffd => Some(0x397au16),
0x60da => Some(0x397bu16),
0x9aa8 => Some(0x397cu16),
0x72db => Some(0x397du16),
0x8fbc => Some(0x397eu16),
0x6b64 => Some(0x3a21u16),
0x9803 => Some(0x3a22u16),
0x4eca => Some(0x3a23u16),
0x56f0 => Some(0x3a24u16),
0x5764 => Some(0x3a25u16),
0x58be => Some(0x3a26u16),
0x5a5a => Some(0x3a27u16),
0x6068 => Some(0x3a28u16),
0x61c7 => Some(0x3a29u16),
0x660f => Some(0x3a2au16),
0x6606 => Some(0x3a2bu16),
0x6839 => Some(0x3a2cu16),
0x68b1 => Some(0x3a2du16),
0x6df7 => Some(0x3a2eu16),
0x75d5 => Some(0x3a2fu16),
0x7d3a => Some(0x3a30u16),
0x826e => Some(0x3a31u16),
0x9b42 => Some(0x3a32u16),
0x4e9b => Some(0x3a33u16),
0x4f50 => Some(0x3a34u16),
0x53c9 => Some(0x3a35u16),
0x5506 => Some(0x3a36u16),
0x5d6f => Some(0x3a37u16),
0x5de6 => Some(0x3a38u16),
0x5dee => Some(0x3a39u16),
0x67fb => Some(0x3a3au16),
0x6c99 => Some(0x3a3bu16),
0x7473 => Some(0x3a3cu16),
0x7802 => Some(0x3a3du16),
0x8a50 => Some(0x3a3eu16),
0x9396 => Some(0x3a3fu16),
0x88df => Some(0x3a40u16),
0x5750 => Some(0x3a41u16),
0x5ea7 => Some(0x3a42u16),
0x632b => Some(0x3a43u16),
0x50b5 => Some(0x3a44u16),
0x50ac => Some(0x3a45u16),
0x518d => Some(0x3a46u16),
0x6700 => Some(0x3a47u16),
0x54c9 => Some(0x3a48u16),
0x585e => Some(0x3a49u16),
0x59bb => Some(0x3a4au16),
0x5bb0 => Some(0x3a4bu16),
0x5f69 => Some(0x3a4cu16),
0x624d => Some(0x3a4du16),
0x63a1 => Some(0x3a4eu16),
0x683d => Some(0x3a4fu16),
0x6b73 => Some(0x3a50u16),
0x6e08 => Some(0x3a51u16),
0x707d => Some(0x3a52u16),
0x91c7 => Some(0x3a53u16),
0x7280 => Some(0x3a54u16),
0x7815 => Some(0x3a55u16),
0x7826 => Some(0x3a56u16),
0x796d => Some(0x3a57u16),
0x658e => Some(0x3a58u16),
0x7d30 => Some(0x3a59u16),
0x83dc => Some(0x3a5au16),
0x88c1 => Some(0x3a5bu16),
0x8f09 => Some(0x3a5cu16),
0x969b => Some(0x3a5du16),
0x5264 => Some(0x3a5eu16),
0x5728 => Some(0x3a5fu16),
0x6750 => Some(0x3a60u16),
0x7f6a => Some(0x3a61u16),
0x8ca1 => Some(0x3a62u16),
0x51b4 => Some(0x3a63u16),
0x5742 => Some(0x3a64u16),
0x962a => Some(0x3a65u16),
0x583a => Some(0x3a66u16),
0x698a => Some(0x3a67u16),
0x80b4 => Some(0x3a68u16),
0x54b2 => Some(0x3a69u16),
0x5d0e => Some(0x3a6au16),
0x57fc => Some(0x3a6bu16),
0x7895 => Some(0x3a6cu16),
0x9dfa => Some(0x3a6du16),
0x4f5c => Some(0x3a6eu16),
0x524a => Some(0x3a6fu16),
0x548b => Some(0x3a70u16),
0x643e => Some(0x3a71u16),
0x6628 => Some(0x3a72u16),
0x6714 => Some(0x3a73u16),
0x67f5 => Some(0x3a74u16),
0x7a84 => Some(0x3a75u16),
0x7b56 => Some(0x3a76u16),
0x7d22 => Some(0x3a77u16),
0x932f => Some(0x3a78u16),
0x685c => Some(0x3a79u16),
0x9bad => Some(0x3a7au16),
0x7b39 => Some(0x3a7bu16),
0x5319 => Some(0x3a7cu16),
0x518a => Some(0x3a7du16),
0x5237 => Some(0x3a7eu16),
0x5bdf => Some(0x3b21u16),
0x62f6 => Some(0x3b22u16),
0x64ae => Some(0x3b23u16),
0x64e6 => Some(0x3b24u16),
0x672d => Some(0x3b25u16),
0x6bba => Some(0x3b26u16),
0x85a9 => Some(0x3b27u16),
0x96d1 => Some(0x3b28u16),
0x7690 => Some(0x3b29u16),
0x9bd6 => Some(0x3b2au16),
0x634c => Some(0x3b2bu16),
0x9306 => Some(0x3b2cu16),
0x9bab => Some(0x3b2du16),
0x76bf => Some(0x3b2eu16),
0x6652 => Some(0x3b2fu16),
0x4e09 => Some(0x3b30u16),
0x5098 => Some(0x3b31u16),
0x53c2 => Some(0x3b32u16),
0x5c71 => Some(0x3b33u16),
0x60e8 => Some(0x3b34u16),
0x6492 => Some(0x3b35u16),
0x6563 => Some(0x3b36u16),
0x685f => Some(0x3b37u16),
0x71e6 => Some(0x3b38u16),
0x73ca => Some(0x3b39u16),
0x7523 => Some(0x3b3au16),
0x7b97 => Some(0x3b3bu16),
0x7e82 => Some(0x3b3cu16),
0x8695 => Some(0x3b3du16),
0x8b83 => Some(0x3b3eu16),
0x8cdb => Some(0x3b3fu16),
0x9178 => Some(0x3b40u16),
0x9910 => Some(0x3b41u16),
0x65ac => Some(0x3b42u16),
0x66ab => Some(0x3b43u16),
0x6b8b => Some(0x3b44u16),
0x4ed5 => Some(0x3b45u16),
0x4ed4 => Some(0x3b46u16),
0x4f3a => Some(0x3b47u16),
0x4f7f => Some(0x3b48u16),
0x523a => Some(0x3b49u16),
0x53f8 => Some(0x3b4au16),
0x53f2 => Some(0x3b4bu16),
0x55e3 => Some(0x3b4cu16),
0x56db => Some(0x3b4du16),
0x58eb => Some(0x3b4eu16),
0x59cb => Some(0x3b4fu16),
0x59c9 => Some(0x3b50u16),
0x59ff => Some(0x3b51u16),
0x5b50 => Some(0x3b52u16),
0x5c4d => Some(0x3b53u16),
0x5e02 => Some(0x3b54u16),
0x5e2b => Some(0x3b55u16),
0x5fd7 => Some(0x3b56u16),
0x601d => Some(0x3b57u16),
0x6307 => Some(0x3b58u16),
0x652f => Some(0x3b59u16),
0x5b5c => Some(0x3b5au16),
0x65af => Some(0x3b5bu16),
0x65bd => Some(0x3b5cu16),
0x65e8 => Some(0x3b5du16),
0x679d => Some(0x3b5eu16),
0x6b62 => Some(0x3b5fu16),
0x6b7b => Some(0x3b60u16),
0x6c0f => Some(0x3b61u16),
0x7345 => Some(0x3b62u16),
0x7949 => Some(0x3b63u16),
0x79c1 => Some(0x3b64u16),
0x7cf8 => Some(0x3b65u16),
0x7d19 => Some(0x3b66u16),
0x7d2b => Some(0x3b67u16),
0x80a2 => Some(0x3b68u16),
0x8102 => Some(0x3b69u16),
0x81f3 => Some(0x3b6au16),
0x8996 => Some(0x3b6bu16),
0x8a5e => Some(0x3b6cu16),
0x8a69 => Some(0x3b6du16),
0x8a66 => Some(0x3b6eu16),
0x8a8c => Some(0x3b6fu16),
0x8aee => Some(0x3b70u16),
0x8cc7 => Some(0x3b71u16),
0x8cdc => Some(0x3b72u16),
0x96cc => Some(0x3b73u16),
0x98fc => Some(0x3b74u16),
0x6b6f => Some(0x3b75u16),
0x4e8b => Some(0x3b76u16),
0x4f3c => Some(0x3b77u16),
0x4f8d => Some(0x3b78u16),
0x5150 => Some(0x3b79u16),
0x5b57 => Some(0x3b7au16),
0x5bfa => Some(0x3b7bu16),
0x6148 => Some(0x3b7cu16),
0x6301 => Some(0x3b7du16),
0x6642 => Some(0x3b7eu16),
0x6b21 => Some(0x3c21u16),
0x6ecb => Some(0x3c22u16),
0x6cbb => Some(0x3c23u16),
0x723e => Some(0x3c24u16),
0x74bd => Some(0x3c25u16),
0x75d4 => Some(0x3c26u16),
0x78c1 => Some(0x3c27u16),
0x793a => Some(0x3c28u16),
0x800c => Some(0x3c29u16),
0x8033 => Some(0x3c2au16),
0x81ea => Some(0x3c2bu16),
0x8494 => Some(0x3c2cu16),
0x8f9e => Some(0x3c2du16),
0x6c50 => Some(0x3c2eu16),
0x9e7f => Some(0x3c2fu16),
0x5f0f => Some(0x3c30u16),
0x8b58 => Some(0x3c31u16),
0x9d2b => Some(0x3c32u16),
0x7afa => Some(0x3c33u16),
0x8ef8 => Some(0x3c34u16),
0x5b8d => Some(0x3c35u16),
0x96eb => Some(0x3c36u16),
0x4e03 => Some(0x3c37u16),
0x53f1 => Some(0x3c38u16),
0x57f7 => Some(0x3c39u16),
0x5931 => Some(0x3c3au16),
0x5ac9 => Some(0x3c3bu16),
0x5ba4 => Some(0x3c3cu16),
0x6089 => Some(0x3c3du16),
0x6e7f => Some(0x3c3eu16),
0x6f06 => Some(0x3c3fu16),
0x75be => Some(0x3c40u16),
0x8cea => Some(0x3c41u16),
0x5b9f => Some(0x3c42u16),
0x8500 => Some(0x3c43u16),
0x7be0 => Some(0x3c44u16),
0x5072 => Some(0x3c45u16),
0x67f4 => Some(0x3c46u16),
0x829d => Some(0x3c47u16),
0x5c61 => Some(0x3c48u16),
0x854a => Some(0x3c49u16),
0x7e1e => Some(0x3c4au16),
0x820e => Some(0x3c4bu16),
0x5199 => Some(0x3c4cu16),
0x5c04 => Some(0x3c4du16),
0x6368 => Some(0x3c4eu16),
0x8d66 => Some(0x3c4fu16),
0x659c => Some(0x3c50u16),
0x716e => Some(0x3c51u16),
0x793e => Some(0x3c52u16),
0x7d17 => Some(0x3c53u16),
0x8005 => Some(0x3c54u16),
0x8b1d => Some(0x3c55u16),
0x8eca => Some(0x3c56u16),
0x906e => Some(0x3c57u16),
0x86c7 => Some(0x3c58u16),
0x90aa => Some(0x3c59u16),
0x501f => Some(0x3c5au16),
0x52fa => Some(0x3c5bu16),
0x5c3a => Some(0x3c5cu16),
0x6753 => Some(0x3c5du16),
0x707c => Some(0x3c5eu16),
0x7235 => Some(0x3c5fu16),
0x914c => Some(0x3c60u16),
0x91c8 => Some(0x3c61u16),
0x932b => Some(0x3c62u16),
0x82e5 => Some(0x3c63u16),
0x5bc2 => Some(0x3c64u16),
0x5f31 => Some(0x3c65u16),
0x60f9 => Some(0x3c66u16),
0x4e3b => Some(0x3c67u16),
0x53d6 => Some(0x3c68u16),
0x5b88 => Some(0x3c69u16),
0x624b => Some(0x3c6au16),
0x6731 => Some(0x3c6bu16),
0x6b8a => Some(0x3c6cu16),
0x72e9 => Some(0x3c6du16),
0x73e0 => Some(0x3c6eu16),
0x7a2e => Some(0x3c6fu16),
0x816b => Some(0x3c70u16),
0x8da3 => Some(0x3c71u16),
0x9152 => Some(0x3c72u16),
0x9996 => Some(0x3c73u16),
0x5112 => Some(0x3c74u16),
0x53d7 => Some(0x3c75u16),
0x546a => Some(0x3c76u16),
0x5bff => Some(0x3c77u16),
0x6388 => Some(0x3c78u16),
0x6a39 => Some(0x3c79u16),
0x7dac => Some(0x3c7au16),
0x9700 => Some(0x3c7bu16),
0x56da => Some(0x3c7cu16),
0x53ce => Some(0x3c7du16),
0x5468 => Some(0x3c7eu16),
0x5b97 => Some(0x3d21u16),
0x5c31 => Some(0x3d22u16),
0x5dde => Some(0x3d23u16),
0x4fee => Some(0x3d24u16),
0x6101 => Some(0x3d25u16),
0x62fe => Some(0x3d26u16),
0x6d32 => Some(0x3d27u16),
0x79c0 => Some(0x3d28u16),
0x79cb => Some(0x3d29u16),
0x7d42 => Some(0x3d2au16),
0x7e4d => Some(0x3d2bu16),
0x7fd2 => Some(0x3d2cu16),
0x81ed => Some(0x3d2du16),
0x821f => Some(0x3d2eu16),
0x8490 => Some(0x3d2fu16),
0x8846 => Some(0x3d30u16),
0x8972 => Some(0x3d31u16),
0x8b90 => Some(0x3d32u16),
0x8e74 => Some(0x3d33u16),
0x8f2f => Some(0x3d34u16),
0x9031 => Some(0x3d35u16),
0x914b => Some(0x3d36u16),
0x916c => Some(0x3d37u16),
0x96c6 => Some(0x3d38u16),
0x919c => Some(0x3d39u16),
0x4ec0 => Some(0x3d3au16),
0x4f4f => Some(0x3d3bu16),
0x5145 => Some(0x3d3cu16),
0x5341 => Some(0x3d3du16),
0x5f93 => Some(0x3d3eu16),
0x620e => Some(0x3d3fu16),
0x67d4 => Some(0x3d40u16),
0x6c41 => Some(0x3d41u16),
0x6e0b => Some(0x3d42u16),
0x7363 => Some(0x3d43u16),
0x7e26 => Some(0x3d44u16),
0x91cd => Some(0x3d45u16),
0x9283 => Some(0x3d46u16),
0x53d4 => Some(0x3d47u16),
0x5919 => Some(0x3d48u16),
0x5bbf => Some(0x3d49u16),
0x6dd1 => Some(0x3d4au16),
0x795d => Some(0x3d4bu16),
0x7e2e => Some(0x3d4cu16),
0x7c9b => Some(0x3d4du16),
0x587e => Some(0x3d4eu16),
0x719f => Some(0x3d4fu16),
0x51fa => Some(0x3d50u16),
0x8853 => Some(0x3d51u16),
0x8ff0 => Some(0x3d52u16),
0x4fca => Some(0x3d53u16),
0x5cfb => Some(0x3d54u16),
0x6625 => Some(0x3d55u16),
0x77ac => Some(0x3d56u16),
0x7ae3 => Some(0x3d57u16),
0x821c => Some(0x3d58u16),
0x99ff => Some(0x3d59u16),
0x51c6 => Some(0x3d5au16),
0x5faa => Some(0x3d5bu16),
0x65ec => Some(0x3d5cu16),
0x696f => Some(0x3d5du16),
0x6b89 => Some(0x3d5eu16),
0x6df3 => Some(0x3d5fu16),
0x6e96 => Some(0x3d60u16),
0x6f64 => Some(0x3d61u16),
0x76fe => Some(0x3d62u16),
0x7d14 => Some(0x3d63u16),
0x5de1 => Some(0x3d64u16),
0x9075 => Some(0x3d65u16),
0x9187 => Some(0x3d66u16),
0x9806 => Some(0x3d67u16),
0x51e6 => Some(0x3d68u16),
0x521d => Some(0x3d69u16),
0x6240 => Some(0x3d6au16),
0x6691 => Some(0x3d6bu16),
0x66d9 => Some(0x3d6cu16),
0x6e1a => Some(0x3d6du16),
0x5eb6 => Some(0x3d6eu16),
0x7dd2 => Some(0x3d6fu16),
0x7f72 => Some(0x3d70u16),
0x66f8 => Some(0x3d71u16),
0x85af => Some(0x3d72u16),
0x85f7 => Some(0x3d73u16),
0x8af8 => Some(0x3d74u16),
0x52a9 => Some(0x3d75u16),
0x53d9 => Some(0x3d76u16),
0x5973 => Some(0x3d77u16),
0x5e8f => Some(0x3d78u16),
0x5f90 => Some(0x3d79u16),
0x6055 => Some(0x3d7au16),
0x92e4 => Some(0x3d7bu16),
0x9664 => Some(0x3d7cu16),
0x50b7 => Some(0x3d7du16),
0x511f => Some(0x3d7eu16),
0x52dd => Some(0x3e21u16),
0x5320 => Some(0x3e22u16),
0x5347 => Some(0x3e23u16),
0x53ec => Some(0x3e24u16),
0x54e8 => Some(0x3e25u16),
0x5546 => Some(0x3e26u16),
0x5531 => Some(0x3e27u16),
0x5617 => Some(0x3e28u16),
0x5968 => Some(0x3e29u16),
0x59be => Some(0x3e2au16),
0x5a3c => Some(0x3e2bu16),
0x5bb5 => Some(0x3e2cu16),
0x5c06 => Some(0x3e2du16),
0x5c0f => Some(0x3e2eu16),
0x5c11 => Some(0x3e2fu16),
0x5c1a => Some(0x3e30u16),
0x5e84 => Some(0x3e31u16),
0x5e8a => Some(0x3e32u16),
0x5ee0 => Some(0x3e33u16),
0x5f70 => Some(0x3e34u16),
0x627f => Some(0x3e35u16),
0x6284 => Some(0x3e36u16),
0x62db => Some(0x3e37u16),
0x638c => Some(0x3e38u16),
0x6377 => Some(0x3e39u16),
0x6607 => Some(0x3e3au16),
0x660c => Some(0x3e3bu16),
0x662d => Some(0x3e3cu16),
0x6676 => Some(0x3e3du16),
0x677e => Some(0x3e3eu16),
0x68a2 => Some(0x3e3fu16),
0x6a1f => Some(0x3e40u16),
0x6a35 => Some(0x3e41u16),
0x6cbc => Some(0x3e42u16),
0x6d88 => Some(0x3e43u16),
0x6e09 => Some(0x3e44u16),
0x6e58 => Some(0x3e45u16),
0x713c => Some(0x3e46u16),
0x7126 => Some(0x3e47u16),
0x7167 => Some(0x3e48u16),
0x75c7 => Some(0x3e49u16),
0x7701 => Some(0x3e4au16),
0x785d => Some(0x3e4bu16),
0x7901 => Some(0x3e4cu16),
0x7965 => Some(0x3e4du16),
0x79f0 => Some(0x3e4eu16),
0x7ae0 => Some(0x3e4fu16),
0x7b11 => Some(0x3e50u16),
0x7ca7 => Some(0x3e51u16),
0x7d39 => Some(0x3e52u16),
0x8096 => Some(0x3e53u16),
0x83d6 => Some(0x3e54u16),
0x848b => Some(0x3e55u16),
0x8549 => Some(0x3e56u16),
0x885d => Some(0x3e57u16),
0x88f3 => Some(0x3e58u16),
0x8a1f => Some(0x3e59u16),
0x8a3c => Some(0x3e5au16),
0x8a54 => Some(0x3e5bu16),
0x8a73 => Some(0x3e5cu16),
0x8c61 => Some(0x3e5du16),
0x8cde => Some(0x3e5eu16),
0x91a4 => Some(0x3e5fu16),
0x9266 => Some(0x3e60u16),
0x937e => Some(0x3e61u16),
0x9418 => Some(0x3e62u16),
0x969c => Some(0x3e63u16),
0x9798 => Some(0x3e64u16),
0x4e0a => Some(0x3e65u16),
0x4e08 => Some(0x3e66u16),
0x4e1e => Some(0x3e67u16),
0x4e57 => Some(0x3e68u16),
0x5197 => Some(0x3e69u16),
0x5270 => Some(0x3e6au16),
0x57ce => Some(0x3e6bu16),
0x5834 => Some(0x3e6cu16),
0x58cc => Some(0x3e6du16),
0x5b22 => Some(0x3e6eu16),
0x5e38 => Some(0x3e6fu16),
0x60c5 => Some(0x3e70u16),
0x64fe => Some(0x3e71u16),
0x6761 => Some(0x3e72u16),
0x6756 => Some(0x3e73u16),
0x6d44 => Some(0x3e74u16),
0x72b6 => Some(0x3e75u16),
0x7573 => Some(0x3e76u16),
0x7a63 => Some(0x3e77u16),
0x84b8 => Some(0x3e78u16),
0x8b72 => Some(0x3e79u16),
0x91b8 => Some(0x3e7au16),
0x9320 => Some(0x3e7bu16),
0x5631 => Some(0x3e7cu16),
0x57f4 => Some(0x3e7du16),
0x98fe => Some(0x3e7eu16),
0x62ed => Some(0x3f21u16),
0x690d => Some(0x3f22u16),
0x6b96 => Some(0x3f23u16),
0x71ed => Some(0x3f24u16),
0x7e54 => Some(0x3f25u16),
0x8077 => Some(0x3f26u16),
0x8272 => Some(0x3f27u16),
0x89e6 => Some(0x3f28u16),
0x98df => Some(0x3f29u16),
0x8755 => Some(0x3f2au16),
0x8fb1 => Some(0x3f2bu16),
0x5c3b => Some(0x3f2cu16),
0x4f38 => Some(0x3f2du16),
0x4fe1 => Some(0x3f2eu16),
0x4fb5 => Some(0x3f2fu16),
0x5507 => Some(0x3f30u16),
0x5a20 => Some(0x3f31u16),
0x5bdd => Some(0x3f32u16),
0x5be9 => Some(0x3f33u16),
0x5fc3 => Some(0x3f34u16),
0x614e => Some(0x3f35u16),
0x632f => Some(0x3f36u16),
0x65b0 => Some(0x3f37u16),
0x664b => Some(0x3f38u16),
0x68ee => Some(0x3f39u16),
0x699b => Some(0x3f3au16),
0x6d78 => Some(0x3f3bu16),
0x6df1 => Some(0x3f3cu16),
0x7533 => Some(0x3f3du16),
0x75b9 => Some(0x3f3eu16),
0x771f => Some(0x3f3fu16),
0x795e => Some(0x3f40u16),
0x79e6 => Some(0x3f41u16),
0x7d33 => Some(0x3f42u16),
0x81e3 => Some(0x3f43u16),
0x82af => Some(0x3f44u16),
0x85aa => Some(0x3f45u16),
0x89aa => Some(0x3f46u16),
0x8a3a => Some(0x3f47u16),
0x8eab => Some(0x3f48u16),
0x8f9b => Some(0x3f49u16),
0x9032 => Some(0x3f4au16),
0x91dd => Some(0x3f4bu16),
0x9707 => Some(0x3f4cu16),
0x4eba => Some(0x3f4du16),
0x4ec1 => Some(0x3f4eu16),
0x5203 => Some(0x3f4fu16),
0x5875 => Some(0x3f50u16),
0x58ec => Some(0x3f51u16),
0x5c0b => Some(0x3f52u16),
0x751a => Some(0x3f53u16),
0x5c3d => Some(0x3f54u16),
0x814e => Some(0x3f55u16),
0x8a0a => Some(0x3f56u16),
0x8fc5 => Some(0x3f57u16),
0x9663 => Some(0x3f58u16),
0x976d => Some(0x3f59u16),
0x7b25 => Some(0x3f5au16),
0x8acf => Some(0x3f5bu16),
0x9808 => Some(0x3f5cu16),
0x9162 => Some(0x3f5du16),
0x56f3 => Some(0x3f5eu16),
0x53a8 => Some(0x3f5fu16),
0x9017 => Some(0x3f60u16),
0x5439 => Some(0x3f61u16),
0x5782 => Some(0x3f62u16),
0x5e25 => Some(0x3f63u16),
0x63a8 => Some(0x3f64u16),
0x6c34 => Some(0x3f65u16),
0x708a => Some(0x3f66u16),
0x7761 => Some(0x3f67u16),
0x7c8b => Some(0x3f68u16),
0x7fe0 => Some(0x3f69u16),
0x8870 => Some(0x3f6au16),
0x9042 => Some(0x3f6bu16),
0x9154 => Some(0x3f6cu16),
0x9310 => Some(0x3f6du16),
0x9318 => Some(0x3f6eu16),
0x968f => Some(0x3f6fu16),
0x745e => Some(0x3f70u16),
0x9ac4 => Some(0x3f71u16),
0x5d07 => Some(0x3f72u16),
0x5d69 => Some(0x3f73u16),
0x6570 => Some(0x3f74u16),
0x67a2 => Some(0x3f75u16),
0x8da8 => Some(0x3f76u16),
0x96db => Some(0x3f77u16),
0x636e => Some(0x3f78u16),
0x6749 => Some(0x3f79u16),
0x6919 => Some(0x3f7au16),
0x83c5 => Some(0x3f7bu16),
0x9817 => Some(0x3f7cu16),
0x96c0 => Some(0x3f7du16),
0x88fe => Some(0x3f7eu16),
0x6f84 => Some(0x4021u16),
0x647a => Some(0x4022u16),
0x5bf8 => Some(0x4023u16),
0x4e16 => Some(0x4024u16),
0x702c => Some(0x4025u16),
0x755d => Some(0x4026u16),
0x662f => Some(0x4027u16),
0x51c4 => Some(0x4028u16),
0x5236 => Some(0x4029u16),
0x52e2 => Some(0x402au16),
0x59d3 => Some(0x402bu16),
0x5f81 => Some(0x402cu16),
0x6027 => Some(0x402du16),
0x6210 => Some(0x402eu16),
0x653f => Some(0x402fu16),
0x6574 => Some(0x4030u16),
0x661f => Some(0x4031u16),
0x6674 => Some(0x4032u16),
0x68f2 => Some(0x4033u16),
0x6816 => Some(0x4034u16),
0x6b63 => Some(0x4035u16),
0x6e05 => Some(0x4036u16),
0x7272 => Some(0x4037u16),
0x751f => Some(0x4038u16),
0x76db => Some(0x4039u16),
0x7cbe => Some(0x403au16),
0x8056 => Some(0x403bu16),
0x58f0 => Some(0x403cu16),
0x88fd => Some(0x403du16),
0x897f => Some(0x403eu16),
0x8aa0 => Some(0x403fu16),
0x8a93 => Some(0x4040u16),
0x8acb => Some(0x4041u16),
0x901d => Some(0x4042u16),
0x9192 => Some(0x4043u16),
0x9752 => Some(0x4044u16),
0x9759 => Some(0x4045u16),
0x6589 => Some(0x4046u16),
0x7a0e => Some(0x4047u16),
0x8106 => Some(0x4048u16),
0x96bb => Some(0x4049u16),
0x5e2d => Some(0x404au16),
0x60dc => Some(0x404bu16),
0x621a => Some(0x404cu16),
0x65a5 => Some(0x404du16),
0x6614 => Some(0x404eu16),
0x6790 => Some(0x404fu16),
0x77f3 => Some(0x4050u16),
0x7a4d => Some(0x4051u16),
0x7c4d => Some(0x4052u16),
0x7e3e => Some(0x4053u16),
0x810a => Some(0x4054u16),
0x8cac => Some(0x4055u16),
0x8d64 => Some(0x4056u16),
0x8de1 => Some(0x4057u16),
0x8e5f => Some(0x4058u16),
0x78a9 => Some(0x4059u16),
0x5207 => Some(0x405au16),
0x62d9 => Some(0x405bu16),
0x63a5 => Some(0x405cu16),
0x6442 => Some(0x405du16),
0x6298 => Some(0x405eu16),
0x8a2d => Some(0x405fu16),
0x7a83 => Some(0x4060u16),
0x7bc0 => Some(0x4061u16),
0x8aac => Some(0x4062u16),
0x96ea => Some(0x4063u16),
0x7d76 => Some(0x4064u16),
0x820c => Some(0x4065u16),
0x8749 => Some(0x4066u16),
0x4ed9 => Some(0x4067u16),
0x5148 => Some(0x4068u16),
0x5343 => Some(0x4069u16),
0x5360 => Some(0x406au16),
0x5ba3 => Some(0x406bu16),
0x5c02 => Some(0x406cu16),
0x5c16 => Some(0x406du16),
0x5ddd => Some(0x406eu16),
0x6226 => Some(0x406fu16),
0x6247 => Some(0x4070u16),
0x64b0 => Some(0x4071u16),
0x6813 => Some(0x4072u16),
0x6834 => Some(0x4073u16),
0x6cc9 => Some(0x4074u16),
0x6d45 => Some(0x4075u16),
0x6d17 => Some(0x4076u16),
0x67d3 => Some(0x4077u16),
0x6f5c => Some(0x4078u16),
0x714e => Some(0x4079u16),
0x717d => Some(0x407au16),
0x65cb => Some(0x407bu16),
0x7a7f => Some(0x407cu16),
0x7bad => Some(0x407du16),
0x7dda => Some(0x407eu16),
0x7e4a => Some(0x4121u16),
0x7fa8 => Some(0x4122u16),
0x817a => Some(0x4123u16),
0x821b => Some(0x4124u16),
0x8239 => Some(0x4125u16),
0x85a6 => Some(0x4126u16),
0x8a6e => Some(0x4127u16),
0x8cce => Some(0x4128u16),
0x8df5 => Some(0x4129u16),
0x9078 => Some(0x412au16),
0x9077 => Some(0x412bu16),
0x92ad => Some(0x412cu16),
0x9291 => Some(0x412du16),
0x9583 => Some(0x412eu16),
0x9bae => Some(0x412fu16),
0x524d => Some(0x4130u16),
0x5584 => Some(0x4131u16),
0x6f38 => Some(0x4132u16),
0x7136 => Some(0x4133u16),
0x5168 => Some(0x4134u16),
0x7985 => Some(0x4135u16),
0x7e55 => Some(0x4136u16),
0x81b3 => Some(0x4137u16),
0x7cce => Some(0x4138u16),
0x564c => Some(0x4139u16),
0x5851 => Some(0x413au16),
0x5ca8 => Some(0x413bu16),
0x63aa => Some(0x413cu16),
0x66fe => Some(0x413du16),
0x66fd => Some(0x413eu16),
0x695a => Some(0x413fu16),
0x72d9 => Some(0x4140u16),
0x758f => Some(0x4141u16),
0x758e => Some(0x4142u16),
0x790e => Some(0x4143u16),
0x7956 => Some(0x4144u16),
0x79df => Some(0x4145u16),
0x7c97 => Some(0x4146u16),
0x7d20 => Some(0x4147u16),
0x7d44 => Some(0x4148u16),
0x8607 => Some(0x4149u16),
0x8a34 => Some(0x414au16),
0x963b => Some(0x414bu16),
0x9061 => Some(0x414cu16),
0x9f20 => Some(0x414du16),
0x50e7 => Some(0x414eu16),
0x5275 => Some(0x414fu16),
0x53cc => Some(0x4150u16),
0x53e2 => Some(0x4151u16),
0x5009 => Some(0x4152u16),
0x55aa => Some(0x4153u16),
0x58ee => Some(0x4154u16),
0x594f => Some(0x4155u16),
0x723d => Some(0x4156u16),
0x5b8b => Some(0x4157u16),
0x5c64 => Some(0x4158u16),
0x531d => Some(0x4159u16),
0x60e3 => Some(0x415au16),
0x60f3 => Some(0x415bu16),
0x635c => Some(0x415cu16),
0x6383 => Some(0x415du16),
0x633f => Some(0x415eu16),
0x63bb => Some(0x415fu16),
0x64cd => Some(0x4160u16),
0x65e9 => Some(0x4161u16),
0x66f9 => Some(0x4162u16),
0x5de3 => Some(0x4163u16),
0x69cd => Some(0x4164u16),
0x69fd => Some(0x4165u16),
0x6f15 => Some(0x4166u16),
0x71e5 => Some(0x4167u16),
0x4e89 => Some(0x4168u16),
0x75e9 => Some(0x4169u16),
0x76f8 => Some(0x416au16),
0x7a93 => Some(0x416bu16),
0x7cdf => Some(0x416cu16),
0x7dcf => Some(0x416du16),
0x7d9c => Some(0x416eu16),
0x8061 => Some(0x416fu16),
0x8349 => Some(0x4170u16),
0x8358 => Some(0x4171u16),
0x846c => Some(0x4172u16),
0x84bc => Some(0x4173u16),
0x85fb => Some(0x4174u16),
0x88c5 => Some(0x4175u16),
0x8d70 => Some(0x4176u16),
0x9001 => Some(0x4177u16),
0x906d => Some(0x4178u16),
0x9397 => Some(0x4179u16),
0x971c => Some(0x417au16),
0x9a12 => Some(0x417bu16),
0x50cf => Some(0x417cu16),
0x5897 => Some(0x417du16),
0x618e => Some(0x417eu16),
0x81d3 => Some(0x4221u16),
0x8535 => Some(0x4222u16),
0x8d08 => Some(0x4223u16),
0x9020 => Some(0x4224u16),
0x4fc3 => Some(0x4225u16),
0x5074 => Some(0x4226u16),
0x5247 => Some(0x4227u16),
0x5373 => Some(0x4228u16),
0x606f => Some(0x4229u16),
0x6349 => Some(0x422au16),
0x675f => Some(0x422bu16),
0x6e2c => Some(0x422cu16),
0x8db3 => Some(0x422du16),
0x901f => Some(0x422eu16),
0x4fd7 => Some(0x422fu16),
0x5c5e => Some(0x4230u16),
0x8cca => Some(0x4231u16),
0x65cf => Some(0x4232u16),
0x7d9a => Some(0x4233u16),
0x5352 => Some(0x4234u16),
0x8896 => Some(0x4235u16),
0x5176 => Some(0x4236u16),
0x63c3 => Some(0x4237u16),
0x5b58 => Some(0x4238u16),
0x5b6b => Some(0x4239u16),
0x5c0a => Some(0x423au16),
0x640d => Some(0x423bu16),
0x6751 => Some(0x423cu16),
0x905c => Some(0x423du16),
0x4ed6 => Some(0x423eu16),
0x591a => Some(0x423fu16),
0x592a => Some(0x4240u16),
0x6c70 => Some(0x4241u16),
0x8a51 => Some(0x4242u16),
0x553e => Some(0x4243u16),
0x5815 => Some(0x4244u16),
0x59a5 => Some(0x4245u16),
0x60f0 => Some(0x4246u16),
0x6253 => Some(0x4247u16),
0x67c1 => Some(0x4248u16),
0x8235 => Some(0x4249u16),
0x6955 => Some(0x424au16),
0x9640 => Some(0x424bu16),
0x99c4 => Some(0x424cu16),
0x9a28 => Some(0x424du16),
0x4f53 => Some(0x424eu16),
0x5806 => Some(0x424fu16),
0x5bfe => Some(0x4250u16),
0x8010 => Some(0x4251u16),
0x5cb1 => Some(0x4252u16),
0x5e2f => Some(0x4253u16),
0x5f85 => Some(0x4254u16),
0x6020 => Some(0x4255u16),
0x614b => Some(0x4256u16),
0x6234 => Some(0x4257u16),
0x66ff => Some(0x4258u16),
0x6cf0 => Some(0x4259u16),
0x6ede => Some(0x425au16),
0x80ce => Some(0x425bu16),
0x817f => Some(0x425cu16),
0x82d4 => Some(0x425du16),
0x888b => Some(0x425eu16),
0x8cb8 => Some(0x425fu16),
0x9000 => Some(0x4260u16),
0x902e => Some(0x4261u16),
0x968a => Some(0x4262u16),
0x9edb => Some(0x4263u16),
0x9bdb => Some(0x4264u16),
0x4ee3 => Some(0x4265u16),
0x53f0 => Some(0x4266u16),
0x5927 => Some(0x4267u16),
0x7b2c => Some(0x4268u16),
0x918d => Some(0x4269u16),
0x984c => Some(0x426au16),
0x9df9 => Some(0x426bu16),
0x6edd => Some(0x426cu16),
0x7027 => Some(0x426du16),
0x5353 => Some(0x426eu16),
0x5544 => Some(0x426fu16),
0x5b85 => Some(0x4270u16),
0x6258 => Some(0x4271u16),
0x629e => Some(0x4272u16),
0x62d3 => Some(0x4273u16),
0x6ca2 => Some(0x4274u16),
0x6fef => Some(0x4275u16),
0x7422 => Some(0x4276u16),
0x8a17 => Some(0x4277u16),
0x9438 => Some(0x4278u16),
0x6fc1 => Some(0x4279u16),
0x8afe => Some(0x427au16),
0x8338 => Some(0x427bu16),
0x51e7 => Some(0x427cu16),
0x86f8 => Some(0x427du16),
0x53ea => Some(0x427eu16),
0x53e9 => Some(0x4321u16),
0x4f46 => Some(0x4322u16),
0x9054 => Some(0x4323u16),
0x8fb0 => Some(0x4324u16),
0x596a => Some(0x4325u16),
0x8131 => Some(0x4326u16),
0x5dfd => Some(0x4327u16),
0x7aea => Some(0x4328u16),
0x8fbf => Some(0x4329u16),
0x68da => Some(0x432au16),
0x8c37 => Some(0x432bu16),
0x72f8 => Some(0x432cu16),
0x9c48 => Some(0x432du16),
0x6a3d => Some(0x432eu16),
0x8ab0 => Some(0x432fu16),
0x4e39 => Some(0x4330u16),
0x5358 => Some(0x4331u16),
0x5606 => Some(0x4332u16),
0x5766 => Some(0x4333u16),
0x62c5 => Some(0x4334u16),
0x63a2 => Some(0x4335u16),
0x65e6 => Some(0x4336u16),
0x6b4e => Some(0x4337u16),
0x6de1 => Some(0x4338u16),
0x6e5b => Some(0x4339u16),
0x70ad => Some(0x433au16),
0x77ed => Some(0x433bu16),
0x7aef => Some(0x433cu16),
0x7baa => Some(0x433du16),
0x7dbb => Some(0x433eu16),
0x803d => Some(0x433fu16),
0x80c6 => Some(0x4340u16),
0x86cb => Some(0x4341u16),
0x8a95 => Some(0x4342u16),
0x935b => Some(0x4343u16),
0x56e3 => Some(0x4344u16),
0x58c7 => Some(0x4345u16),
0x5f3e => Some(0x4346u16),
0x65ad => Some(0x4347u16),
0x6696 => Some(0x4348u16),
0x6a80 => Some(0x4349u16),
0x6bb5 => Some(0x434au16),
0x7537 => Some(0x434bu16),
0x8ac7 => Some(0x434cu16),
0x5024 => Some(0x434du16),
0x77e5 => Some(0x434eu16),
0x5730 => Some(0x434fu16),
0x5f1b => Some(0x4350u16),
0x6065 => Some(0x4351u16),
0x667a => Some(0x4352u16),
0x6c60 => Some(0x4353u16),
0x75f4 => Some(0x4354u16),
0x7a1a => Some(0x4355u16),
0x7f6e => Some(0x4356u16),
0x81f4 => Some(0x4357u16),
0x8718 => Some(0x4358u16),
0x9045 => Some(0x4359u16),
0x99b3 => Some(0x435au16),
0x7bc9 => Some(0x435bu16),
0x755c => Some(0x435cu16),
0x7af9 => Some(0x435du16),
0x7b51 => Some(0x435eu16),
0x84c4 => Some(0x435fu16),
0x9010 => Some(0x4360u16),
0x79e9 => Some(0x4361u16),
0x7a92 => Some(0x4362u16),
0x8336 => Some(0x4363u16),
0x5ae1 => Some(0x4364u16),
0x7740 => Some(0x4365u16),
0x4e2d => Some(0x4366u16),
0x4ef2 => Some(0x4367u16),
0x5b99 => Some(0x4368u16),
0x5fe0 => Some(0x4369u16),
0x62bd => Some(0x436au16),
0x663c => Some(0x436bu16),
0x67f1 => Some(0x436cu16),
0x6ce8 => Some(0x436du16),
0x866b => Some(0x436eu16),
0x8877 => Some(0x436fu16),
0x8a3b => Some(0x4370u16),
0x914e => Some(0x4371u16),
0x92f3 => Some(0x4372u16),
0x99d0 => Some(0x4373u16),
0x6a17 => Some(0x4374u16),
0x7026 => Some(0x4375u16),
0x732a => Some(0x4376u16),
0x82e7 => Some(0x4377u16),
0x8457 => Some(0x4378u16),
0x8caf => Some(0x4379u16),
0x4e01 => Some(0x437au16),
0x5146 => Some(0x437bu16),
0x51cb => Some(0x437cu16),
0x558b => Some(0x437du16),
0x5bf5 => Some(0x437eu16),
0x5e16 => Some(0x4421u16),
0x5e33 => Some(0x4422u16),
0x5e81 => Some(0x4423u16),
0x5f14 => Some(0x4424u16),
0x5f35 => Some(0x4425u16),
0x5f6b => Some(0x4426u16),
0x5fb4 => Some(0x4427u16),
0x61f2 => Some(0x4428u16),
0x6311 => Some(0x4429u16),
0x66a2 => Some(0x442au16),
0x671d => Some(0x442bu16),
0x6f6e => Some(0x442cu16),
0x7252 => Some(0x442du16),
0x753a => Some(0x442eu16),
0x773a => Some(0x442fu16),
0x8074 => Some(0x4430u16),
0x8139 => Some(0x4431u16),
0x8178 => Some(0x4432u16),
0x8776 => Some(0x4433u16),
0x8abf => Some(0x4434u16),
0x8adc => Some(0x4435u16),
0x8d85 => Some(0x4436u16),
0x8df3 => Some(0x4437u16),
0x929a => Some(0x4438u16),
0x9577 => Some(0x4439u16),
0x9802 => Some(0x443au16),
0x9ce5 => Some(0x443bu16),
0x52c5 => Some(0x443cu16),
0x6357 => Some(0x443du16),
0x76f4 => Some(0x443eu16),
0x6715 => Some(0x443fu16),
0x6c88 => Some(0x4440u16),
0x73cd => Some(0x4441u16),
0x8cc3 => Some(0x4442u16),
0x93ae => Some(0x4443u16),
0x9673 => Some(0x4444u16),
0x6d25 => Some(0x4445u16),
0x589c => Some(0x4446u16),
0x690e => Some(0x4447u16),
0x69cc => Some(0x4448u16),
0x8ffd => Some(0x4449u16),
0x939a => Some(0x444au16),
0x75db => Some(0x444bu16),
0x901a => Some(0x444cu16),
0x585a => Some(0x444du16),
0x6802 => Some(0x444eu16),
0x63b4 => Some(0x444fu16),
0x69fb => Some(0x4450u16),
0x4f43 => Some(0x4451u16),
0x6f2c => Some(0x4452u16),
0x67d8 => Some(0x4453u16),
0x8fbb => Some(0x4454u16),
0x8526 => Some(0x4455u16),
0x7db4 => Some(0x4456u16),
0x9354 => Some(0x4457u16),
0x693f => Some(0x4458u16),
0x6f70 => Some(0x4459u16),
0x576a => Some(0x445au16),
0x58f7 => Some(0x445bu16),
0x5b2c => Some(0x445cu16),
0x7d2c => Some(0x445du16),
0x722a => Some(0x445eu16),
0x540a => Some(0x445fu16),
0x91e3 => Some(0x4460u16),
0x9db4 => Some(0x4461u16),
0x4ead => Some(0x4462u16),
0x4f4e => Some(0x4463u16),
0x505c => Some(0x4464u16),
0x5075 => Some(0x4465u16),
0x5243 => Some(0x4466u16),
0x8c9e => Some(0x4467u16),
0x5448 => Some(0x4468u16),
0x5824 => Some(0x4469u16),
0x5b9a => Some(0x446au16),
0x5e1d => Some(0x446bu16),
0x5e95 => Some(0x446cu16),
0x5ead => Some(0x446du16),
0x5ef7 => Some(0x446eu16),
0x5f1f => Some(0x446fu16),
0x608c => Some(0x4470u16),
0x62b5 => Some(0x4471u16),
0x633a => Some(0x4472u16),
0x63d0 => Some(0x4473u16),
0x68af => Some(0x4474u16),
0x6c40 => Some(0x4475u16),
0x7887 => Some(0x4476u16),
0x798e => Some(0x4477u16),
0x7a0b => Some(0x4478u16),
0x7de0 => Some(0x4479u16),
0x8247 => Some(0x447au16),
0x8a02 => Some(0x447bu16),
0x8ae6 => Some(0x447cu16),
0x8e44 => Some(0x447du16),
0x9013 => Some(0x447eu16),
0x90b8 => Some(0x4521u16),
0x912d => Some(0x4522u16),
0x91d8 => Some(0x4523u16),
0x9f0e => Some(0x4524u16),
0x6ce5 => Some(0x4525u16),
0x6458 => Some(0x4526u16),
0x64e2 => Some(0x4527u16),
0x6575 => Some(0x4528u16),
0x6ef4 => Some(0x4529u16),
0x7684 => Some(0x452au16),
0x7b1b => Some(0x452bu16),
0x9069 => Some(0x452cu16),
0x93d1 => Some(0x452du16),
0x6eba => Some(0x452eu16),
0x54f2 => Some(0x452fu16),
0x5fb9 => Some(0x4530u16),
0x64a4 => Some(0x4531u16),
0x8f4d => Some(0x4532u16),
0x8fed => Some(0x4533u16),
0x9244 => Some(0x4534u16),
0x5178 => Some(0x4535u16),
0x586b => Some(0x4536u16),
0x5929 => Some(0x4537u16),
0x5c55 => Some(0x4538u16),
0x5e97 => Some(0x4539u16),
0x6dfb => Some(0x453au16),
0x7e8f => Some(0x453bu16),
0x751c => Some(0x453cu16),
0x8cbc => Some(0x453du16),
0x8ee2 => Some(0x453eu16),
0x985b => Some(0x453fu16),
0x70b9 => Some(0x4540u16),
0x4f1d => Some(0x4541u16),
0x6bbf => Some(0x4542u16),
0x6fb1 => Some(0x4543u16),
0x7530 => Some(0x4544u16),
0x96fb => Some(0x4545u16),
0x514e => Some(0x4546u16),
0x5410 => Some(0x4547u16),
0x5835 => Some(0x4548u16),
0x5857 => Some(0x4549u16),
0x59ac => Some(0x454au16),
0x5c60 => Some(0x454bu16),
0x5f92 => Some(0x454cu16),
0x6597 => Some(0x454du16),
0x675c => Some(0x454eu16),
0x6e21 => Some(0x454fu16),
0x767b => Some(0x4550u16),
0x83df => Some(0x4551u16),
0x8ced => Some(0x4552u16),
0x9014 => Some(0x4553u16),
0x90fd => Some(0x4554u16),
0x934d => Some(0x4555u16),
0x7825 => Some(0x4556u16),
0x783a => Some(0x4557u16),
0x52aa => Some(0x4558u16),
0x5ea6 => Some(0x4559u16),
0x571f => Some(0x455au16),
0x5974 => Some(0x455bu16),
0x6012 => Some(0x455cu16),
0x5012 => Some(0x455du16),
0x515a => Some(0x455eu16),
0x51ac => Some(0x455fu16),
0x51cd => Some(0x4560u16),
0x5200 => Some(0x4561u16),
0x5510 => Some(0x4562u16),
0x5854 => Some(0x4563u16),
0x5858 => Some(0x4564u16),
0x5957 => Some(0x4565u16),
0x5b95 => Some(0x4566u16),
0x5cf6 => Some(0x4567u16),
0x5d8b => Some(0x4568u16),
0x60bc => Some(0x4569u16),
0x6295 => Some(0x456au16),
0x642d => Some(0x456bu16),
0x6771 => Some(0x456cu16),
0x6843 => Some(0x456du16),
0x68bc => Some(0x456eu16),
0x68df => Some(0x456fu16),
0x76d7 => Some(0x4570u16),
0x6dd8 => Some(0x4571u16),
0x6e6f => Some(0x4572u16),
0x6d9b => Some(0x4573u16),
0x706f => Some(0x4574u16),
0x71c8 => Some(0x4575u16),
0x5f53 => Some(0x4576u16),
0x75d8 => Some(0x4577u16),
0x7977 => Some(0x4578u16),
0x7b49 => Some(0x4579u16),
0x7b54 => Some(0x457au16),
0x7b52 => Some(0x457bu16),
0x7cd6 => Some(0x457cu16),
0x7d71 => Some(0x457du16),
0x5230 => Some(0x457eu16),
0x8463 => Some(0x4621u16),
0x8569 => Some(0x4622u16),
0x85e4 => Some(0x4623u16),
0x8a0e => Some(0x4624u16),
0x8b04 => Some(0x4625u16),
0x8c46 => Some(0x4626u16),
0x8e0f => Some(0x4627u16),
0x9003 => Some(0x4628u16),
0x900f => Some(0x4629u16),
0x9419 => Some(0x462au16),
0x9676 => Some(0x462bu16),
0x982d => Some(0x462cu16),
0x9a30 => Some(0x462du16),
0x95d8 => Some(0x462eu16),
0x50cd => Some(0x462fu16),
0x52d5 => Some(0x4630u16),
0x540c => Some(0x4631u16),
0x5802 => Some(0x4632u16),
0x5c0e => Some(0x4633u16),
0x61a7 => Some(0x4634u16),
0x649e => Some(0x4635u16),
0x6d1e => Some(0x4636u16),
0x77b3 => Some(0x4637u16),
0x7ae5 => Some(0x4638u16),
0x80f4 => Some(0x4639u16),
0x8404 => Some(0x463au16),
0x9053 => Some(0x463bu16),
0x9285 => Some(0x463cu16),
0x5ce0 => Some(0x463du16),
0x9d07 => Some(0x463eu16),
0x533f => Some(0x463fu16),
0x5f97 => Some(0x4640u16),
0x5fb3 => Some(0x4641u16),
0x6d9c => Some(0x4642u16),
0x7279 => Some(0x4643u16),
0x7763 => Some(0x4644u16),
0x79bf => Some(0x4645u16),
0x7be4 => Some(0x4646u16),
0x6bd2 => Some(0x4647u16),
0x72ec => Some(0x4648u16),
0x8aad => Some(0x4649u16),
0x6803 => Some(0x464au16),
0x6a61 => Some(0x464bu16),
0x51f8 => Some(0x464cu16),
0x7a81 => Some(0x464du16),
0x6934 => Some(0x464eu16),
0x5c4a => Some(0x464fu16),
0x9cf6 => Some(0x4650u16),
0x82eb => Some(0x4651u16),
0x5bc5 => Some(0x4652u16),
0x9149 => Some(0x4653u16),
0x701e => Some(0x4654u16),
0x5678 => Some(0x4655u16),
0x5c6f => Some(0x4656u16),
0x60c7 => Some(0x4657u16),
0x6566 => Some(0x4658u16),
0x6c8c => Some(0x4659u16),
0x8c5a => Some(0x465au16),
0x9041 => Some(0x465bu16),
0x9813 => Some(0x465cu16),
0x5451 => Some(0x465du16),
0x66c7 => Some(0x465eu16),
0x920d => Some(0x465fu16),
0x5948 => Some(0x4660u16),
0x90a3 => Some(0x4661u16),
0x5185 => Some(0x4662u16),
0x4e4d => Some(0x4663u16),
0x51ea => Some(0x4664u16),
0x8599 => Some(0x4665u16),
0x8b0e => Some(0x4666u16),
0x7058 => Some(0x4667u16),
0x637a => Some(0x4668u16),
0x934b => Some(0x4669u16),
0x6962 => Some(0x466au16),
0x99b4 => Some(0x466bu16),
0x7e04 => Some(0x466cu16),
0x7577 => Some(0x466du16),
0x5357 => Some(0x466eu16),
0x6960 => Some(0x466fu16),
0x8edf => Some(0x4670u16),
0x96e3 => Some(0x4671u16),
0x6c5d => Some(0x4672u16),
0x4e8c => Some(0x4673u16),
0x5c3c => Some(0x4674u16),
0x5f10 => Some(0x4675u16),
0x8fe9 => Some(0x4676u16),
0x5302 => Some(0x4677u16),
0x8cd1 => Some(0x4678u16),
0x8089 => Some(0x4679u16),
0x8679 => Some(0x467au16),
0x5eff => Some(0x467bu16),
0x65e5 => Some(0x467cu16),
0x4e73 => Some(0x467du16),
0x5165 => Some(0x467eu16),
0x5982 => Some(0x4721u16),
0x5c3f => Some(0x4722u16),
0x97ee => Some(0x4723u16),
0x4efb => Some(0x4724u16),
0x598a => Some(0x4725u16),
0x5fcd => Some(0x4726u16),
0x8a8d => Some(0x4727u16),
0x6fe1 => Some(0x4728u16),
0x79b0 => Some(0x4729u16),
0x7962 => Some(0x472au16),
0x5be7 => Some(0x472bu16),
0x8471 => Some(0x472cu16),
0x732b => Some(0x472du16),
0x71b1 => Some(0x472eu16),
0x5e74 => Some(0x472fu16),
0x5ff5 => Some(0x4730u16),
0x637b => Some(0x4731u16),
0x649a => Some(0x4732u16),
0x71c3 => Some(0x4733u16),
0x7c98 => Some(0x4734u16),
0x4e43 => Some(0x4735u16),
0x5efc => Some(0x4736u16),
0x4e4b => Some(0x4737u16),
0x57dc => Some(0x4738u16),
0x56a2 => Some(0x4739u16),
0x60a9 => Some(0x473au16),
0x6fc3 => Some(0x473bu16),
0x7d0d => Some(0x473cu16),
0x80fd => Some(0x473du16),
0x8133 => Some(0x473eu16),
0x81bf => Some(0x473fu16),
0x8fb2 => Some(0x4740u16),
0x8997 => Some(0x4741u16),
0x86a4 => Some(0x4742u16),
0x5df4 => Some(0x4743u16),
0x628a => Some(0x4744u16),
0x64ad => Some(0x4745u16),
0x8987 => Some(0x4746u16),
0x6777 => Some(0x4747u16),
0x6ce2 => Some(0x4748u16),
0x6d3e => Some(0x4749u16),
0x7436 => Some(0x474au16),
0x7834 => Some(0x474bu16),
0x5a46 => Some(0x474cu16),
0x7f75 => Some(0x474du16),
0x82ad => Some(0x474eu16),
0x99ac => Some(0x474fu16),
0x4ff3 => Some(0x4750u16),
0x5ec3 => Some(0x4751u16),
0x62dd => Some(0x4752u16),
0x6392 => Some(0x4753u16),
0x6557 => Some(0x4754u16),
0x676f => Some(0x4755u16),
0x76c3 => Some(0x4756u16),
0x724c => Some(0x4757u16),
0x80cc => Some(0x4758u16),
0x80ba => Some(0x4759u16),
0x8f29 => Some(0x475au16),
0x914d => Some(0x475bu16),
0x500d => Some(0x475cu16),
0x57f9 => Some(0x475du16),
0x5a92 => Some(0x475eu16),
0x6885 => Some(0x475fu16),
0x6973 => Some(0x4760u16),
0x7164 => Some(0x4761u16),
0x72fd => Some(0x4762u16),
0x8cb7 => Some(0x4763u16),
0x58f2 => Some(0x4764u16),
0x8ce0 => Some(0x4765u16),
0x966a => Some(0x4766u16),
0x9019 => Some(0x4767u16),
0x877f => Some(0x4768u16),
0x79e4 => Some(0x4769u16),
0x77e7 => Some(0x476au16),
0x8429 => Some(0x476bu16),
0x4f2f => Some(0x476cu16),
0x5265 => Some(0x476du16),
0x535a => Some(0x476eu16),
0x62cd => Some(0x476fu16),
0x67cf => Some(0x4770u16),
0x6cca => Some(0x4771u16),
0x767d => Some(0x4772u16),
0x7b94 => Some(0x4773u16),
0x7c95 => Some(0x4774u16),
0x8236 => Some(0x4775u16),
0x8584 => Some(0x4776u16),
0x8feb => Some(0x4777u16),
0x66dd => Some(0x4778u16),
0x6f20 => Some(0x4779u16),
0x7206 => Some(0x477au16),
0x7e1b => Some(0x477bu16),
0x83ab => Some(0x477cu16),
0x99c1 => Some(0x477du16),
0x9ea6 => Some(0x477eu16),
0x51fd => Some(0x4821u16),
0x7bb1 => Some(0x4822u16),
0x7872 => Some(0x4823u16),
0x7bb8 => Some(0x4824u16),
0x8087 => Some(0x4825u16),
0x7b48 => Some(0x4826u16),
0x6ae8 => Some(0x4827u16),
0x5e61 => Some(0x4828u16),
0x808c => Some(0x4829u16),
0x7551 => Some(0x482au16),
0x7560 => Some(0x482bu16),
0x516b => Some(0x482cu16),
0x9262 => Some(0x482du16),
0x6e8c => Some(0x482eu16),
0x767a => Some(0x482fu16),
0x9197 => Some(0x4830u16),
0x9aea => Some(0x4831u16),
0x4f10 => Some(0x4832u16),
0x7f70 => Some(0x4833u16),
0x629c => Some(0x4834u16),
0x7b4f => Some(0x4835u16),
0x95a5 => Some(0x4836u16),
0x9ce9 => Some(0x4837u16),
0x567a => Some(0x4838u16),
0x5859 => Some(0x4839u16),
0x86e4 => Some(0x483au16),
0x96bc => Some(0x483bu16),
0x4f34 => Some(0x483cu16),
0x5224 => Some(0x483du16),
0x534a => Some(0x483eu16),
0x53cd => Some(0x483fu16),
0x53db => Some(0x4840u16),
0x5e06 => Some(0x4841u16),
0x642c => Some(0x4842u16),
0x6591 => Some(0x4843u16),
0x677f => Some(0x4844u16),
0x6c3e => Some(0x4845u16),
0x6c4e => Some(0x4846u16),
0x7248 => Some(0x4847u16),
0x72af => Some(0x4848u16),
0x73ed => Some(0x4849u16),
0x7554 => Some(0x484au16),
0x7e41 => Some(0x484bu16),
0x822c => Some(0x484cu16),
0x85e9 => Some(0x484du16),
0x8ca9 => Some(0x484eu16),
0x7bc4 => Some(0x484fu16),
0x91c6 => Some(0x4850u16),
0x7169 => Some(0x4851u16),
0x9812 => Some(0x4852u16),
0x98ef => Some(0x4853u16),
0x633d => Some(0x4854u16),
0x6669 => Some(0x4855u16),
0x756a => Some(0x4856u16),
0x76e4 => Some(0x4857u16),
0x78d0 => Some(0x4858u16),
0x8543 => Some(0x4859u16),
0x86ee => Some(0x485au16),
0x532a => Some(0x485bu16),
0x5351 => Some(0x485cu16),
0x5426 => Some(0x485du16),
0x5983 => Some(0x485eu16),
0x5e87 => Some(0x485fu16),
0x5f7c => Some(0x4860u16),
0x60b2 => Some(0x4861u16),
0x6249 => Some(0x4862u16),
0x6279 => Some(0x4863u16),
0x62ab => Some(0x4864u16),
0x6590 => Some(0x4865u16),
0x6bd4 => Some(0x4866u16),
0x6ccc => Some(0x4867u16),
0x75b2 => Some(0x4868u16),
0x76ae => Some(0x4869u16),
0x7891 => Some(0x486au16),
0x79d8 => Some(0x486bu16),
0x7dcb => Some(0x486cu16),
0x7f77 => Some(0x486du16),
0x80a5 => Some(0x486eu16),
0x88ab => Some(0x486fu16),
0x8ab9 => Some(0x4870u16),
0x8cbb => Some(0x4871u16),
0x907f => Some(0x4872u16),
0x975e => Some(0x4873u16),
0x98db => Some(0x4874u16),
0x6a0b => Some(0x4875u16),
0x7c38 => Some(0x4876u16),
0x5099 => Some(0x4877u16),
0x5c3e => Some(0x4878u16),
0x5fae => Some(0x4879u16),
0x6787 => Some(0x487au16),
0x6bd8 => Some(0x487bu16),
0x7435 => Some(0x487cu16),
0x7709 => Some(0x487du16),
0x7f8e => Some(0x487eu16),
0x9f3b => Some(0x4921u16),
0x67ca => Some(0x4922u16),
0x7a17 => Some(0x4923u16),
0x5339 => Some(0x4924u16),
0x758b => Some(0x4925u16),
0x9aed => Some(0x4926u16),
0x5f66 => Some(0x4927u16),
0x819d => Some(0x4928u16),
0x83f1 => Some(0x4929u16),
0x8098 => Some(0x492au16),
0x5f3c => Some(0x492bu16),
0x5fc5 => Some(0x492cu16),
0x7562 => Some(0x492du16),
0x7b46 => Some(0x492eu16),
0x903c => Some(0x492fu16),
0x6867 => Some(0x4930u16),
0x59eb => Some(0x4931u16),
0x5a9b => Some(0x4932u16),
0x7d10 => Some(0x4933u16),
0x767e => Some(0x4934u16),
0x8b2c => Some(0x4935u16),
0x4ff5 => Some(0x4936u16),
0x5f6a => Some(0x4937u16),
0x6a19 => Some(0x4938u16),
0x6c37 => Some(0x4939u16),
0x6f02 => Some(0x493au16),
0x74e2 => Some(0x493bu16),
0x7968 => Some(0x493cu16),
0x8868 => Some(0x493du16),
0x8a55 => Some(0x493eu16),
0x8c79 => Some(0x493fu16),
0x5edf => Some(0x4940u16),
0x63cf => Some(0x4941u16),
0x75c5 => Some(0x4942u16),
0x79d2 => Some(0x4943u16),
0x82d7 => Some(0x4944u16),
0x9328 => Some(0x4945u16),
0x92f2 => Some(0x4946u16),
0x849c => Some(0x4947u16),
0x86ed => Some(0x4948u16),
0x9c2d => Some(0x4949u16),
0x54c1 => Some(0x494au16),
0x5f6c => Some(0x494bu16),
0x658c => Some(0x494cu16),
0x6d5c => Some(0x494du16),
0x7015 => Some(0x494eu16),
0x8ca7 => Some(0x494fu16),
0x8cd3 => Some(0x4950u16),
0x983b => Some(0x4951u16),
0x654f => Some(0x4952u16),
0x74f6 => Some(0x4953u16),
0x4e0d => Some(0x4954u16),
0x4ed8 => Some(0x4955u16),
0x57e0 => Some(0x4956u16),
0x592b => Some(0x4957u16),
0x5a66 => Some(0x4958u16),
0x5bcc => Some(0x4959u16),
0x51a8 => Some(0x495au16),
0x5e03 => Some(0x495bu16),
0x5e9c => Some(0x495cu16),
0x6016 => Some(0x495du16),
0x6276 => Some(0x495eu16),
0x6577 => Some(0x495fu16),
0x65a7 => Some(0x4960u16),
0x666e => Some(0x4961u16),
0x6d6e => Some(0x4962u16),
0x7236 => Some(0x4963u16),
0x7b26 => Some(0x4964u16),
0x8150 => Some(0x4965u16),
0x819a => Some(0x4966u16),
0x8299 => Some(0x4967u16),
0x8b5c => Some(0x4968u16),
0x8ca0 => Some(0x4969u16),
0x8ce6 => Some(0x496au16),
0x8d74 => Some(0x496bu16),
0x961c => Some(0x496cu16),
0x9644 => Some(0x496du16),
0x4fae => Some(0x496eu16),
0x64ab => Some(0x496fu16),
0x6b66 => Some(0x4970u16),
0x821e => Some(0x4971u16),
0x8461 => Some(0x4972u16),
0x856a => Some(0x4973u16),
0x90e8 => Some(0x4974u16),
0x5c01 => Some(0x4975u16),
0x6953 => Some(0x4976u16),
0x98a8 => Some(0x4977u16),
0x847a => Some(0x4978u16),
0x8557 => Some(0x4979u16),
0x4f0f => Some(0x497au16),
0x526f => Some(0x497bu16),
0x5fa9 => Some(0x497cu16),
0x5e45 => Some(0x497du16),
0x670d => Some(0x497eu16),
0x798f => Some(0x4a21u16),
0x8179 => Some(0x4a22u16),
0x8907 => Some(0x4a23u16),
0x8986 => Some(0x4a24u16),
0x6df5 => Some(0x4a25u16),
0x5f17 => Some(0x4a26u16),
0x6255 => Some(0x4a27u16),
0x6cb8 => Some(0x4a28u16),
0x4ecf => Some(0x4a29u16),
0x7269 => Some(0x4a2au16),
0x9b92 => Some(0x4a2bu16),
0x5206 => Some(0x4a2cu16),
0x543b => Some(0x4a2du16),
0x5674 => Some(0x4a2eu16),
0x58b3 => Some(0x4a2fu16),
0x61a4 => Some(0x4a30u16),
0x626e => Some(0x4a31u16),
0x711a => Some(0x4a32u16),
0x596e => Some(0x4a33u16),
0x7c89 => Some(0x4a34u16),
0x7cde => Some(0x4a35u16),
0x7d1b => Some(0x4a36u16),
0x96f0 => Some(0x4a37u16),
0x6587 => Some(0x4a38u16),
0x805e => Some(0x4a39u16),
0x4e19 => Some(0x4a3au16),
0x4f75 => Some(0x4a3bu16),
0x5175 => Some(0x4a3cu16),
0x5840 => Some(0x4a3du16),
0x5e63 => Some(0x4a3eu16),
0x5e73 => Some(0x4a3fu16),
0x5f0a => Some(0x4a40u16),
0x67c4 => Some(0x4a41u16),
0x4e26 => Some(0x4a42u16),
0x853d => Some(0x4a43u16),
0x9589 => Some(0x4a44u16),
0x965b => Some(0x4a45u16),
0x7c73 => Some(0x4a46u16),
0x9801 => Some(0x4a47u16),
0x50fb => Some(0x4a48u16),
0x58c1 => Some(0x4a49u16),
0x7656 => Some(0x4a4au16),
0x78a7 => Some(0x4a4bu16),
0x5225 => Some(0x4a4cu16),
0x77a5 => Some(0x4a4du16),
0x8511 => Some(0x4a4eu16),
0x7b86 => Some(0x4a4fu16),
0x504f => Some(0x4a50u16),
0x5909 => Some(0x4a51u16),
0x7247 => Some(0x4a52u16),
0x7bc7 => Some(0x4a53u16),
0x7de8 => Some(0x4a54u16),
0x8fba => Some(0x4a55u16),
0x8fd4 => Some(0x4a56u16),
0x904d => Some(0x4a57u16),
0x4fbf => Some(0x4a58u16),
0x52c9 => Some(0x4a59u16),
0x5a29 => Some(0x4a5au16),
0x5f01 => Some(0x4a5bu16),
0x97ad => Some(0x4a5cu16),
0x4fdd => Some(0x4a5du16),
0x8217 => Some(0x4a5eu16),
0x92ea => Some(0x4a5fu16),
0x5703 => Some(0x4a60u16),
0x6355 => Some(0x4a61u16),
0x6b69 => Some(0x4a62u16),
0x752b => Some(0x4a63u16),
0x88dc => Some(0x4a64u16),
0x8f14 => Some(0x4a65u16),
0x7a42 => Some(0x4a66u16),
0x52df => Some(0x4a67u16),
0x5893 => Some(0x4a68u16),
0x6155 => Some(0x4a69u16),
0x620a => Some(0x4a6au16),
0x66ae => Some(0x4a6bu16),
0x6bcd => Some(0x4a6cu16),
0x7c3f => Some(0x4a6du16),
0x83e9 => Some(0x4a6eu16),
0x5023 => Some(0x4a6fu16),
0x4ff8 => Some(0x4a70u16),
0x5305 => Some(0x4a71u16),
0x5446 => Some(0x4a72u16),
0x5831 => Some(0x4a73u16),
0x5949 => Some(0x4a74u16),
0x5b9d => Some(0x4a75u16),
0x5cf0 => Some(0x4a76u16),
0x5cef => Some(0x4a77u16),
0x5d29 => Some(0x4a78u16),
0x5e96 => Some(0x4a79u16),
0x62b1 => Some(0x4a7au16),
0x6367 => Some(0x4a7bu16),
0x653e => Some(0x4a7cu16),
0x65b9 => Some(0x4a7du16),
0x670b => Some(0x4a7eu16),
0x6cd5 => Some(0x4b21u16),
0x6ce1 => Some(0x4b22u16),
0x70f9 => Some(0x4b23u16),
0x7832 => Some(0x4b24u16),
0x7e2b => Some(0x4b25u16),
0x80de => Some(0x4b26u16),
0x82b3 => Some(0x4b27u16),
0x840c => Some(0x4b28u16),
0x84ec => Some(0x4b29u16),
0x8702 => Some(0x4b2au16),
0x8912 => Some(0x4b2bu16),
0x8a2a => Some(0x4b2cu16),
0x8c4a => Some(0x4b2du16),
0x90a6 => Some(0x4b2eu16),
0x92d2 => Some(0x4b2fu16),
0x98fd => Some(0x4b30u16),
0x9cf3 => Some(0x4b31u16),
0x9d6c => Some(0x4b32u16),
0x4e4f => Some(0x4b33u16),
0x4ea1 => Some(0x4b34u16),
0x508d => Some(0x4b35u16),
0x5256 => Some(0x4b36u16),
0x574a => Some(0x4b37u16),
0x59a8 => Some(0x4b38u16),
0x5e3d => Some(0x4b39u16),
0x5fd8 => Some(0x4b3au16),
0x5fd9 => Some(0x4b3bu16),
0x623f => Some(0x4b3cu16),
0x66b4 => Some(0x4b3du16),
0x671b => Some(0x4b3eu16),
0x67d0 => Some(0x4b3fu16),
0x68d2 => Some(0x4b40u16),
0x5192 => Some(0x4b41u16),
0x7d21 => Some(0x4b42u16),
0x80aa => Some(0x4b43u16),
0x81a8 => Some(0x4b44u16),
0x8b00 => Some(0x4b45u16),
0x8c8c => Some(0x4b46u16),
0x8cbf => Some(0x4b47u16),
0x927e => Some(0x4b48u16),
0x9632 => Some(0x4b49u16),
0x5420 => Some(0x4b4au16),
0x982c => Some(0x4b4bu16),
0x5317 => Some(0x4b4cu16),
0x50d5 => Some(0x4b4du16),
0x535c => Some(0x4b4eu16),
0x58a8 => Some(0x4b4fu16),
0x64b2 => Some(0x4b50u16),
0x6734 => Some(0x4b51u16),
0x7267 => Some(0x4b52u16),
0x7766 => Some(0x4b53u16),
0x7a46 => Some(0x4b54u16),
0x91e6 => Some(0x4b55u16),
0x52c3 => Some(0x4b56u16),
0x6ca1 => Some(0x4b57u16),
0x6b86 => Some(0x4b58u16),
0x5800 => Some(0x4b59u16),
0x5e4c => Some(0x4b5au16),
0x5954 => Some(0x4b5bu16),
0x672c => Some(0x4b5cu16),
0x7ffb => Some(0x4b5du16),
0x51e1 => Some(0x4b5eu16),
0x76c6 => Some(0x4b5fu16),
0x6469 => Some(0x4b60u16),
0x78e8 => Some(0x4b61u16),
0x9b54 => Some(0x4b62u16),
0x9ebb => Some(0x4b63u16),
0x57cb => Some(0x4b64u16),
0x59b9 => Some(0x4b65u16),
0x6627 => Some(0x4b66u16),
0x679a => Some(0x4b67u16),
0x6bce => Some(0x4b68u16),
0x54e9 => Some(0x4b69u16),
0x69d9 => Some(0x4b6au16),
0x5e55 => Some(0x4b6bu16),
0x819c => Some(0x4b6cu16),
0x6795 => Some(0x4b6du16),
0x9baa => Some(0x4b6eu16),
0x67fe => Some(0x4b6fu16),
0x9c52 => Some(0x4b70u16),
0x685d => Some(0x4b71u16),
0x4ea6 => Some(0x4b72u16),
0x4fe3 => Some(0x4b73u16),
0x53c8 => Some(0x4b74u16),
0x62b9 => Some(0x4b75u16),
0x672b => Some(0x4b76u16),
0x6cab => Some(0x4b77u16),
0x8fc4 => Some(0x4b78u16),
0x4fad => Some(0x4b79u16),
0x7e6d => Some(0x4b7au16),
0x9ebf => Some(0x4b7bu16),
0x4e07 => Some(0x4b7cu16),
0x6162 => Some(0x4b7du16),
0x6e80 => Some(0x4b7eu16),
0x6f2b => Some(0x4c21u16),
0x8513 => Some(0x4c22u16),
0x5473 => Some(0x4c23u16),
0x672a => Some(0x4c24u16),
0x9b45 => Some(0x4c25u16),
0x5df3 => Some(0x4c26u16),
0x7b95 => Some(0x4c27u16),
0x5cac => Some(0x4c28u16),
0x5bc6 => Some(0x4c29u16),
0x871c => Some(0x4c2au16),
0x6e4a => Some(0x4c2bu16),
0x84d1 => Some(0x4c2cu16),
0x7a14 => Some(0x4c2du16),
0x8108 => Some(0x4c2eu16),
0x5999 => Some(0x4c2fu16),
0x7c8d => Some(0x4c30u16),
0x6c11 => Some(0x4c31u16),
0x7720 => Some(0x4c32u16),
0x52d9 => Some(0x4c33u16),
0x5922 => Some(0x4c34u16),
0x7121 => Some(0x4c35u16),
0x725f => Some(0x4c36u16),
0x77db => Some(0x4c37u16),
0x9727 => Some(0x4c38u16),
0x9d61 => Some(0x4c39u16),
0x690b => Some(0x4c3au16),
0x5a7f => Some(0x4c3bu16),
0x5a18 => Some(0x4c3cu16),
0x51a5 => Some(0x4c3du16),
0x540d => Some(0x4c3eu16),
0x547d => Some(0x4c3fu16),
0x660e => Some(0x4c40u16),
0x76df => Some(0x4c41u16),
0x8ff7 => Some(0x4c42u16),
0x9298 => Some(0x4c43u16),
0x9cf4 => Some(0x4c44u16),
0x59ea => Some(0x4c45u16),
0x725d => Some(0x4c46u16),
0x6ec5 => Some(0x4c47u16),
0x514d => Some(0x4c48u16),
0x68c9 => Some(0x4c49u16),
0x7dbf => Some(0x4c4au16),
0x7dec => Some(0x4c4bu16),
0x9762 => Some(0x4c4cu16),
0x9eba => Some(0x4c4du16),
0x6478 => Some(0x4c4eu16),
0x6a21 => Some(0x4c4fu16),
0x8302 => Some(0x4c50u16),
0x5984 => Some(0x4c51u16),
0x5b5f => Some(0x4c52u16),
0x6bdb => Some(0x4c53u16),
0x731b => Some(0x4c54u16),
0x76f2 => Some(0x4c55u16),
0x7db2 => Some(0x4c56u16),
0x8017 => Some(0x4c57u16),
0x8499 => Some(0x4c58u16),
0x5132 => Some(0x4c59u16),
0x6728 => Some(0x4c5au16),
0x9ed9 => Some(0x4c5bu16),
0x76ee => Some(0x4c5cu16),
0x6762 => Some(0x4c5du16),
0x52ff => Some(0x4c5eu16),
0x9905 => Some(0x4c5fu16),
0x5c24 => Some(0x4c60u16),
0x623b => Some(0x4c61u16),
0x7c7e => Some(0x4c62u16),
0x8cb0 => Some(0x4c63u16),
0x554f => Some(0x4c64u16),
0x60b6 => Some(0x4c65u16),
0x7d0b => Some(0x4c66u16),
0x9580 => Some(0x4c67u16),
0x5301 => Some(0x4c68u16),
0x4e5f => Some(0x4c69u16),
0x51b6 => Some(0x4c6au16),
0x591c => Some(0x4c6bu16),
0x723a => Some(0x4c6cu16),
0x8036 => Some(0x4c6du16),
0x91ce => Some(0x4c6eu16),
0x5f25 => Some(0x4c6fu16),
0x77e2 => Some(0x4c70u16),
0x5384 => Some(0x4c71u16),
0x5f79 => Some(0x4c72u16),
0x7d04 => Some(0x4c73u16),
0x85ac => Some(0x4c74u16),
0x8a33 => Some(0x4c75u16),
0x8e8d => Some(0x4c76u16),
0x9756 => Some(0x4c77u16),
0x67f3 => Some(0x4c78u16),
0x85ae => Some(0x4c79u16),
0x9453 => Some(0x4c7au16),
0x6109 => Some(0x4c7bu16),
0x6108 => Some(0x4c7cu16),
0x6cb9 => Some(0x4c7du16),
0x7652 => Some(0x4c7eu16),
0x8aed => Some(0x4d21u16),
0x8f38 => Some(0x4d22u16),
0x552f => Some(0x4d23u16),
0x4f51 => Some(0x4d24u16),
0x512a => Some(0x4d25u16),
0x52c7 => Some(0x4d26u16),
0x53cb => Some(0x4d27u16),
0x5ba5 => Some(0x4d28u16),
0x5e7d => Some(0x4d29u16),
0x60a0 => Some(0x4d2au16),
0x6182 => Some(0x4d2bu16),
0x63d6 => Some(0x4d2cu16),
0x6709 => Some(0x4d2du16),
0x67da => Some(0x4d2eu16),
0x6e67 => Some(0x4d2fu16),
0x6d8c => Some(0x4d30u16),
0x7336 => Some(0x4d31u16),
0x7337 => Some(0x4d32u16),
0x7531 => Some(0x4d33u16),
0x7950 => Some(0x4d34u16),
0x88d5 => Some(0x4d35u16),
0x8a98 => Some(0x4d36u16),
0x904a => Some(0x4d37u16),
0x9091 => Some(0x4d38u16),
0x90f5 => Some(0x4d39u16),
0x96c4 => Some(0x4d3au16),
0x878d => Some(0x4d3bu16),
0x5915 => Some(0x4d3cu16),
0x4e88 => Some(0x4d3du16),
0x4f59 => Some(0x4d3eu16),
0x4e0e => Some(0x4d3fu16),
0x8a89 => Some(0x4d40u16),
0x8f3f => Some(0x4d41u16),
0x9810 => Some(0x4d42u16),
0x50ad => Some(0x4d43u16),
0x5e7c => Some(0x4d44u16),
0x5996 => Some(0x4d45u16),
0x5bb9 => Some(0x4d46u16),
0x5eb8 => Some(0x4d47u16),
0x63da => Some(0x4d48u16),
0x63fa => Some(0x4d49u16),
0x64c1 => Some(0x4d4au16),
0x66dc => Some(0x4d4bu16),
0x694a => Some(0x4d4cu16),
0x69d8 => Some(0x4d4du16),
0x6d0b => Some(0x4d4eu16),
0x6eb6 => Some(0x4d4fu16),
0x7194 => Some(0x4d50u16),
0x7528 => Some(0x4d51u16),
0x7aaf => Some(0x4d52u16),
0x7f8a => Some(0x4d53u16),
0x8000 => Some(0x4d54u16),
0x8449 => Some(0x4d55u16),
0x84c9 => Some(0x4d56u16),
0x8981 => Some(0x4d57u16),
0x8b21 => Some(0x4d58u16),
0x8e0a => Some(0x4d59u16),
0x9065 => Some(0x4d5au16),
0x967d => Some(0x4d5bu16),
0x990a => Some(0x4d5cu16),
0x617e => Some(0x4d5du16),
0x6291 => Some(0x4d5eu16),
0x6b32 => Some(0x4d5fu16),
0x6c83 => Some(0x4d60u16),
0x6d74 => Some(0x4d61u16),
0x7fcc => Some(0x4d62u16),
0x7ffc => Some(0x4d63u16),
0x6dc0 => Some(0x4d64u16),
0x7f85 => Some(0x4d65u16),
0x87ba => Some(0x4d66u16),
0x88f8 => Some(0x4d67u16),
0x6765 => Some(0x4d68u16),
0x83b1 => Some(0x4d69u16),
0x983c => Some(0x4d6au16),
0x96f7 => Some(0x4d6bu16),
0x6d1b => Some(0x4d6cu16),
0x7d61 => Some(0x4d6du16),
0x843d => Some(0x4d6eu16),
0x916a => Some(0x4d6fu16),
0x4e71 => Some(0x4d70u16),
0x5375 => Some(0x4d71u16),
0x5d50 => Some(0x4d72u16),
0x6b04 => Some(0x4d73u16),
0x6feb => Some(0x4d74u16),
0x85cd => Some(0x4d75u16),
0x862d => Some(0x4d76u16),
0x89a7 => Some(0x4d77u16),
0x5229 => Some(0x4d78u16),
0x540f => Some(0x4d79u16),
0x5c65 => Some(0x4d7au16),
0x674e => Some(0x4d7bu16),
0x68a8 => Some(0x4d7cu16),
0x7406 => Some(0x4d7du16),
0x7483 => Some(0x4d7eu16),
0x75e2 => Some(0x4e21u16),
0x88cf => Some(0x4e22u16),
0x88e1 => Some(0x4e23u16),
0x91cc => Some(0x4e24u16),
0x96e2 => Some(0x4e25u16),
0x9678 => Some(0x4e26u16),
0x5f8b => Some(0x4e27u16),
0x7387 => Some(0x4e28u16),
0x7acb => Some(0x4e29u16),
0x844e => Some(0x4e2au16),
0x63a0 => Some(0x4e2bu16),
0x7565 => Some(0x4e2cu16),
0x5289 => Some(0x4e2du16),
0x6d41 => Some(0x4e2eu16),
0x6e9c => Some(0x4e2fu16),
0x7409 => Some(0x4e30u16),
0x7559 => Some(0x4e31u16),
0x786b => Some(0x4e32u16),
0x7c92 => Some(0x4e33u16),
0x9686 => Some(0x4e34u16),
0x7adc => Some(0x4e35u16),
0x9f8d => Some(0x4e36u16),
0x4fb6 => Some(0x4e37u16),
0x616e => Some(0x4e38u16),
0x65c5 => Some(0x4e39u16),
0x865c => Some(0x4e3au16),
0x4e86 => Some(0x4e3bu16),
0x4eae => Some(0x4e3cu16),
0x50da => Some(0x4e3du16),
0x4e21 => Some(0x4e3eu16),
0x51cc => Some(0x4e3fu16),
0x5bee => Some(0x4e40u16),
0x6599 => Some(0x4e41u16),
0x6881 => Some(0x4e42u16),
0x6dbc => Some(0x4e43u16),
0x731f => Some(0x4e44u16),
0x7642 => Some(0x4e45u16),
0x77ad => Some(0x4e46u16),
0x7a1c => Some(0x4e47u16),
0x7ce7 => Some(0x4e48u16),
0x826f => Some(0x4e49u16),
0x8ad2 => Some(0x4e4au16),
0x907c => Some(0x4e4bu16),
0x91cf => Some(0x4e4cu16),
0x9675 => Some(0x4e4du16),
0x9818 => Some(0x4e4eu16),
0x529b => Some(0x4e4fu16),
0x7dd1 => Some(0x4e50u16),
0x502b => Some(0x4e51u16),
0x5398 => Some(0x4e52u16),
0x6797 => Some(0x4e53u16),
0x6dcb => Some(0x4e54u16),
0x71d0 => Some(0x4e55u16),
0x7433 => Some(0x4e56u16),
0x81e8 => Some(0x4e57u16),
0x8f2a => Some(0x4e58u16),
0x96a3 => Some(0x4e59u16),
0x9c57 => Some(0x4e5au16),
0x9e9f => Some(0x4e5bu16),
0x7460 => Some(0x4e5cu16),
0x5841 => Some(0x4e5du16),
0x6d99 => Some(0x4e5eu16),
0x7d2f => Some(0x4e5fu16),
0x985e => Some(0x4e60u16),
0x4ee4 => Some(0x4e61u16),
0x4f36 => Some(0x4e62u16),
0x4f8b => Some(0x4e63u16),
0x51b7 => Some(0x4e64u16),
0x52b1 => Some(0x4e65u16),
0x5dba => Some(0x4e66u16),
0x601c => Some(0x4e67u16),
0x73b2 => Some(0x4e68u16),
0x793c => Some(0x4e69u16),
0x82d3 => Some(0x4e6au16),
0x9234 => Some(0x4e6bu16),
0x96b7 => Some(0x4e6cu16),
0x96f6 => Some(0x4e6du16),
0x970a => Some(0x4e6eu16),
0x9e97 => Some(0x4e6fu16),
0x9f62 => Some(0x4e70u16),
0x66a6 => Some(0x4e71u16),
0x6b74 => Some(0x4e72u16),
0x5217 => Some(0x4e73u16),
0x52a3 => Some(0x4e74u16),
0x70c8 => Some(0x4e75u16),
0x88c2 => Some(0x4e76u16),
0x5ec9 => Some(0x4e77u16),
0x604b => Some(0x4e78u16),
0x6190 => Some(0x4e79u16),
0x6f23 => Some(0x4e7au16),
0x7149 => Some(0x4e7bu16),
0x7c3e => Some(0x4e7cu16),
0x7df4 => Some(0x4e7du16),
0x806f => Some(0x4e7eu16),
0x84ee => Some(0x4f21u16),
0x9023 => Some(0x4f22u16),
0x932c => Some(0x4f23u16),
0x5442 => Some(0x4f24u16),
0x9b6f => Some(0x4f25u16),
0x6ad3 => Some(0x4f26u16),
0x7089 => Some(0x4f27u16),
0x8cc2 => Some(0x4f28u16),
0x8def => Some(0x4f29u16),
0x9732 => Some(0x4f2au16),
0x52b4 => Some(0x4f2bu16),
0x5a41 => Some(0x4f2cu16),
0x5eca => Some(0x4f2du16),
0x5f04 => Some(0x4f2eu16),
0x6717 => Some(0x4f2fu16),
0x697c => Some(0x4f30u16),
0x6994 => Some(0x4f31u16),
0x6d6a => Some(0x4f32u16),
0x6f0f => Some(0x4f33u16),
0x7262 => Some(0x4f34u16),
0x72fc => Some(0x4f35u16),
0x7bed => Some(0x4f36u16),
0x8001 => Some(0x4f37u16),
0x807e => Some(0x4f38u16),
0x874b => Some(0x4f39u16),
0x90ce => Some(0x4f3au16),
0x516d => Some(0x4f3bu16),
0x9e93 => Some(0x4f3cu16),
0x7984 => Some(0x4f3du16),
0x808b => Some(0x4f3eu16),
0x9332 => Some(0x4f3fu16),
0x8ad6 => Some(0x4f40u16),
0x502d => Some(0x4f41u16),
0x548c => Some(0x4f42u16),
0x8a71 => Some(0x4f43u16),
0x6b6a => Some(0x4f44u16),
0x8cc4 => Some(0x4f45u16),
0x8107 => Some(0x4f46u16),
0x60d1 => Some(0x4f47u16),
0x67a0 => Some(0x4f48u16),
0x9df2 => Some(0x4f49u16),
0x4e99 => Some(0x4f4au16),
0x4e98 => Some(0x4f4bu16),
0x9c10 => Some(0x4f4cu16),
0x8a6b => Some(0x4f4du16),
0x85c1 => Some(0x4f4eu16),
0x8568 => Some(0x4f4fu16),
0x6900 => Some(0x4f50u16),
0x6e7e => Some(0x4f51u16),
0x7897 => Some(0x4f52u16),
0x8155 => Some(0x4f53u16),
0x5f0c => Some(0x5021u16),
0x4e10 => Some(0x5022u16),
0x4e15 => Some(0x5023u16),
0x4e2a => Some(0x5024u16),
0x4e31 => Some(0x5025u16),
0x4e36 => Some(0x5026u16),
0x4e3c => Some(0x5027u16),
0x4e3f => Some(0x5028u16),
0x4e42 => Some(0x5029u16),
0x4e56 => Some(0x502au16),
0x4e58 => Some(0x502bu16),
0x4e82 => Some(0x502cu16),
0x4e85 => Some(0x502du16),
0x8c6b => Some(0x502eu16),
0x4e8a => Some(0x502fu16),
0x8212 => Some(0x5030u16),
0x5f0d => Some(0x5031u16),
0x4e8e => Some(0x5032u16),
0x4e9e => Some(0x5033u16),
0x4e9f => Some(0x5034u16),
0x4ea0 => Some(0x5035u16),
0x4ea2 => Some(0x5036u16),
0x4eb0 => Some(0x5037u16),
0x4eb3 => Some(0x5038u16),
0x4eb6 => Some(0x5039u16),
0x4ece => Some(0x503au16),
0x4ecd => Some(0x503bu16),
0x4ec4 => Some(0x503cu16),
0x4ec6 => Some(0x503du16),
0x4ec2 => Some(0x503eu16),
0x4ed7 => Some(0x503fu16),
0x4ede => Some(0x5040u16),
0x4eed => Some(0x5041u16),
0x4edf => Some(0x5042u16),
0x4ef7 => Some(0x5043u16),
0x4f09 => Some(0x5044u16),
0x4f5a => Some(0x5045u16),
0x4f30 => Some(0x5046u16),
0x4f5b => Some(0x5047u16),
0x4f5d => Some(0x5048u16),
0x4f57 => Some(0x5049u16),
0x4f47 => Some(0x504au16),
0x4f76 => Some(0x504bu16),
0x4f88 => Some(0x504cu16),
0x4f8f => Some(0x504du16),
0x4f98 => Some(0x504eu16),
0x4f7b => Some(0x504fu16),
0x4f69 => Some(0x5050u16),
0x4f70 => Some(0x5051u16),
0x4f91 => Some(0x5052u16),
0x4f6f => Some(0x5053u16),
0x4f86 => Some(0x5054u16),
0x4f96 => Some(0x5055u16),
0x5118 => Some(0x5056u16),
0x4fd4 => Some(0x5057u16),
0x4fdf => Some(0x5058u16),
0x4fce => Some(0x5059u16),
0x4fd8 => Some(0x505au16),
0x4fdb => Some(0x505bu16),
0x4fd1 => Some(0x505cu16),
0x4fda => Some(0x505du16),
0x4fd0 => Some(0x505eu16),
0x4fe4 => Some(0x505fu16),
0x4fe5 => Some(0x5060u16),
0x501a => Some(0x5061u16),
0x5028 => Some(0x5062u16),
0x5014 => Some(0x5063u16),
0x502a => Some(0x5064u16),
0x5025 => Some(0x5065u16),
0x5005 => Some(0x5066u16),
0x4f1c => Some(0x5067u16),
0x4ff6 => Some(0x5068u16),
0x5021 => Some(0x5069u16),
0x5029 => Some(0x506au16),
0x502c => Some(0x506bu16),
0x4ffe => Some(0x506cu16),
0x4fef => Some(0x506du16),
0x5011 => Some(0x506eu16),
0x5006 => Some(0x506fu16),
0x5043 => Some(0x5070u16),
0x5047 => Some(0x5071u16),
0x6703 => Some(0x5072u16),
0x5055 => Some(0x5073u16),
0x5050 => Some(0x5074u16),
0x5048 => Some(0x5075u16),
0x505a => Some(0x5076u16),
0x5056 => Some(0x5077u16),
0x506c => Some(0x5078u16),
0x5078 => Some(0x5079u16),
0x5080 => Some(0x507au16),
0x509a => Some(0x507bu16),
0x5085 => Some(0x507cu16),
0x50b4 => Some(0x507du16),
0x50b2 => Some(0x507eu16),
0x50c9 => Some(0x5121u16),
0x50ca => Some(0x5122u16),
0x50b3 => Some(0x5123u16),
0x50c2 => Some(0x5124u16),
0x50d6 => Some(0x5125u16),
0x50de => Some(0x5126u16),
0x50e5 => Some(0x5127u16),
0x50ed => Some(0x5128u16),
0x50e3 => Some(0x5129u16),
0x50ee => Some(0x512au16),
0x50f9 => Some(0x512bu16),
0x50f5 => Some(0x512cu16),
0x5109 => Some(0x512du16),
0x5101 => Some(0x512eu16),
0x5102 => Some(0x512fu16),
0x5116 => Some(0x5130u16),
0x5115 => Some(0x5131u16),
0x5114 => Some(0x5132u16),
0x511a => Some(0x5133u16),
0x5121 => Some(0x5134u16),
0x513a => Some(0x5135u16),
0x5137 => Some(0x5136u16),
0x513c => Some(0x5137u16),
0x513b => Some(0x5138u16),
0x513f => Some(0x5139u16),
0x5140 => Some(0x513au16),
0x5152 => Some(0x513bu16),
0x514c => Some(0x513cu16),
0x5154 => Some(0x513du16),
0x5162 => Some(0x513eu16),
0x7af8 => Some(0x513fu16),
0x5169 => Some(0x5140u16),
0x516a => Some(0x5141u16),
0x516e => Some(0x5142u16),
0x5180 => Some(0x5143u16),
0x5182 => Some(0x5144u16),
0x56d8 => Some(0x5145u16),
0x518c => Some(0x5146u16),
0x5189 => Some(0x5147u16),
0x518f => Some(0x5148u16),
0x5191 => Some(0x5149u16),
0x5193 => Some(0x514au16),
0x5195 => Some(0x514bu16),
0x5196 => Some(0x514cu16),
0x51a4 => Some(0x514du16),
0x51a6 => Some(0x514eu16),
0x51a2 => Some(0x514fu16),
0x51a9 => Some(0x5150u16),
0x51aa => Some(0x5151u16),
0x51ab => Some(0x5152u16),
0x51b3 => Some(0x5153u16),
0x51b1 => Some(0x5154u16),
0x51b2 => Some(0x5155u16),
0x51b0 => Some(0x5156u16),
0x51b5 => Some(0x5157u16),
0x51bd => Some(0x5158u16),
0x51c5 => Some(0x5159u16),
0x51c9 => Some(0x515au16),
0x51db => Some(0x515bu16),
0x51e0 => Some(0x515cu16),
0x8655 => Some(0x515du16),
0x51e9 => Some(0x515eu16),
0x51ed => Some(0x515fu16),
0x51f0 => Some(0x5160u16),
0x51f5 => Some(0x5161u16),
0x51fe => Some(0x5162u16),
0x5204 => Some(0x5163u16),
0x520b => Some(0x5164u16),
0x5214 => Some(0x5165u16),
0x520e => Some(0x5166u16),
0x5227 => Some(0x5167u16),
0x522a => Some(0x5168u16),
0x522e => Some(0x5169u16),
0x5233 => Some(0x516au16),
0x5239 => Some(0x516bu16),
0x524f => Some(0x516cu16),
0x5244 => Some(0x516du16),
0x524b => Some(0x516eu16),
0x524c => Some(0x516fu16),
0x525e => Some(0x5170u16),
0x5254 => Some(0x5171u16),
0x526a => Some(0x5172u16),
0x5274 => Some(0x5173u16),
0x5269 => Some(0x5174u16),
0x5273 => Some(0x5175u16),
0x527f => Some(0x5176u16),
0x527d => Some(0x5177u16),
0x528d => Some(0x5178u16),
0x5294 => Some(0x5179u16),
0x5292 => Some(0x517au16),
0x5271 => Some(0x517bu16),
0x5288 => Some(0x517cu16),
0x5291 => Some(0x517du16),
0x8fa8 => Some(0x517eu16),
0x8fa7 => Some(0x5221u16),
0x52ac => Some(0x5222u16),
0x52ad => Some(0x5223u16),
0x52bc => Some(0x5224u16),
0x52b5 => Some(0x5225u16),
0x52c1 => Some(0x5226u16),
0x52cd => Some(0x5227u16),
0x52d7 => Some(0x5228u16),
0x52de => Some(0x5229u16),
0x52e3 => Some(0x522au16),
0x52e6 => Some(0x522bu16),
0x98ed => Some(0x522cu16),
0x52e0 => Some(0x522du16),
0x52f3 => Some(0x522eu16),
0x52f5 => Some(0x522fu16),
0x52f8 => Some(0x5230u16),
0x52f9 => Some(0x5231u16),
0x5306 => Some(0x5232u16),
0x5308 => Some(0x5233u16),
0x7538 => Some(0x5234u16),
0x530d => Some(0x5235u16),
0x5310 => Some(0x5236u16),
0x530f => Some(0x5237u16),
0x5315 => Some(0x5238u16),
0x531a => Some(0x5239u16),
0x5323 => Some(0x523au16),
0x532f => Some(0x523bu16),
0x5331 => Some(0x523cu16),
0x5333 => Some(0x523du16),
0x5338 => Some(0x523eu16),
0x5340 => Some(0x523fu16),
0x5346 => Some(0x5240u16),
0x5345 => Some(0x5241u16),
0x4e17 => Some(0x5242u16),
0x5349 => Some(0x5243u16),
0x534d => Some(0x5244u16),
0x51d6 => Some(0x5245u16),
0x535e => Some(0x5246u16),
0x5369 => Some(0x5247u16),
0x536e => Some(0x5248u16),
0x5918 => Some(0x5249u16),
0x537b => Some(0x524au16),
0x5377 => Some(0x524bu16),
0x5382 => Some(0x524cu16),
0x5396 => Some(0x524du16),
0x53a0 => Some(0x524eu16),
0x53a6 => Some(0x524fu16),
0x53a5 => Some(0x5250u16),
0x53ae => Some(0x5251u16),
0x53b0 => Some(0x5252u16),
0x53b6 => Some(0x5253u16),
0x53c3 => Some(0x5254u16),
0x7c12 => Some(0x5255u16),
0x96d9 => Some(0x5256u16),
0x53df => Some(0x5257u16),
0x66fc => Some(0x5258u16),
0x71ee => Some(0x5259u16),
0x53ee => Some(0x525au16),
0x53e8 => Some(0x525bu16),
0x53ed => Some(0x525cu16),
0x53fa => Some(0x525du16),
0x5401 => Some(0x525eu16),
0x543d => Some(0x525fu16),
0x5440 => Some(0x5260u16),
0x542c => Some(0x5261u16),
0x542d => Some(0x5262u16),
0x543c => Some(0x5263u16),
0x542e => Some(0x5264u16),
0x5436 => Some(0x5265u16),
0x5429 => Some(0x5266u16),
0x541d => Some(0x5267u16),
0x544e => Some(0x5268u16),
0x548f => Some(0x5269u16),
0x5475 => Some(0x526au16),
0x548e => Some(0x526bu16),
0x545f => Some(0x526cu16),
0x5471 => Some(0x526du16),
0x5477 => Some(0x526eu16),
0x5470 => Some(0x526fu16),
0x5492 => Some(0x5270u16),
0x547b => Some(0x5271u16),
0x5480 => Some(0x5272u16),
0x5476 => Some(0x5273u16),
0x5484 => Some(0x5274u16),
0x5490 => Some(0x5275u16),
0x5486 => Some(0x5276u16),
0x54c7 => Some(0x5277u16),
0x54a2 => Some(0x5278u16),
0x54b8 => Some(0x5279u16),
0x54a5 => Some(0x527au16),
0x54ac => Some(0x527bu16),
0x54c4 => Some(0x527cu16),
0x54c8 => Some(0x527du16),
0x54a8 => Some(0x527eu16),
0x54ab => Some(0x5321u16),
0x54c2 => Some(0x5322u16),
0x54a4 => Some(0x5323u16),
0x54be => Some(0x5324u16),
0x54bc => Some(0x5325u16),
0x54d8 => Some(0x5326u16),
0x54e5 => Some(0x5327u16),
0x54e6 => Some(0x5328u16),
0x550f => Some(0x5329u16),
0x5514 => Some(0x532au16),
0x54fd => Some(0x532bu16),
0x54ee => Some(0x532cu16),
0x54ed => Some(0x532du16),
0x54fa => Some(0x532eu16),
0x54e2 => Some(0x532fu16),
0x5539 => Some(0x5330u16),
0x5540 => Some(0x5331u16),
0x5563 => Some(0x5332u16),
0x554c => Some(0x5333u16),
0x552e => Some(0x5334u16),
0x555c => Some(0x5335u16),
0x5545 => Some(0x5336u16),
0x5556 => Some(0x5337u16),
0x5557 => Some(0x5338u16),
0x5538 => Some(0x5339u16),
0x5533 => Some(0x533au16),
0x555d => Some(0x533bu16),
0x5599 => Some(0x533cu16),
0x5580 => Some(0x533du16),
0x54af => Some(0x533eu16),
0x558a => Some(0x533fu16),
0x559f => Some(0x5340u16),
0x557b => Some(0x5341u16),
0x557e => Some(0x5342u16),
0x5598 => Some(0x5343u16),
0x559e => Some(0x5344u16),
0x55ae => Some(0x5345u16),
0x557c => Some(0x5346u16),
0x5583 => Some(0x5347u16),
0x55a9 => Some(0x5348u16),
0x5587 => Some(0x5349u16),
0x55a8 => Some(0x534au16),
0x55da => Some(0x534bu16),
0x55c5 => Some(0x534cu16),
0x55df => Some(0x534du16),
0x55c4 => Some(0x534eu16),
0x55dc => Some(0x534fu16),
0x55e4 => Some(0x5350u16),
0x55d4 => Some(0x5351u16),
0x5614 => Some(0x5352u16),
0x55f7 => Some(0x5353u16),
0x5616 => Some(0x5354u16),
0x55fe => Some(0x5355u16),
0x55fd => Some(0x5356u16),
0x561b => Some(0x5357u16),
0x55f9 => Some(0x5358u16),
0x564e => Some(0x5359u16),
0x5650 => Some(0x535au16),
0x71df => Some(0x535bu16),
0x5634 => Some(0x535cu16),
0x5636 => Some(0x535du16),
0x5632 => Some(0x535eu16),
0x5638 => Some(0x535fu16),
0x566b => Some(0x5360u16),
0x5664 => Some(0x5361u16),
0x562f => Some(0x5362u16),
0x566c => Some(0x5363u16),
0x566a => Some(0x5364u16),
0x5686 => Some(0x5365u16),
0x5680 => Some(0x5366u16),
0x568a => Some(0x5367u16),
0x56a0 => Some(0x5368u16),
0x5694 => Some(0x5369u16),
0x568f => Some(0x536au16),
0x56a5 => Some(0x536bu16),
0x56ae => Some(0x536cu16),
0x56b6 => Some(0x536du16),
0x56b4 => Some(0x536eu16),
0x56c2 => Some(0x536fu16),
0x56bc => Some(0x5370u16),
0x56c1 => Some(0x5371u16),
0x56c3 => Some(0x5372u16),
0x56c0 => Some(0x5373u16),
0x56c8 => Some(0x5374u16),
0x56ce => Some(0x5375u16),
0x56d1 => Some(0x5376u16),
0x56d3 => Some(0x5377u16),
0x56d7 => Some(0x5378u16),
0x56ee => Some(0x5379u16),
0x56f9 => Some(0x537au16),
0x5700 => Some(0x537bu16),
0x56ff => Some(0x537cu16),
0x5704 => Some(0x537du16),
0x5709 => Some(0x537eu16),
0x5708 => Some(0x5421u16),
0x570b => Some(0x5422u16),
0x570d => Some(0x5423u16),
0x5713 => Some(0x5424u16),
0x5718 => Some(0x5425u16),
0x5716 => Some(0x5426u16),
0x55c7 => Some(0x5427u16),
0x571c => Some(0x5428u16),
0x5726 => Some(0x5429u16),
0x5737 => Some(0x542au16),
0x5738 => Some(0x542bu16),
0x574e => Some(0x542cu16),
0x573b => Some(0x542du16),
0x5740 => Some(0x542eu16),
0x574f => Some(0x542fu16),
0x5769 => Some(0x5430u16),
0x57c0 => Some(0x5431u16),
0x5788 => Some(0x5432u16),
0x5761 => Some(0x5433u16),
0x577f => Some(0x5434u16),
0x5789 => Some(0x5435u16),
0x5793 => Some(0x5436u16),
0x57a0 => Some(0x5437u16),
0x57b3 => Some(0x5438u16),
0x57a4 => Some(0x5439u16),
0x57aa => Some(0x543au16),
0x57b0 => Some(0x543bu16),
0x57c3 => Some(0x543cu16),
0x57c6 => Some(0x543du16),
0x57d4 => Some(0x543eu16),
0x57d2 => Some(0x543fu16),
0x57d3 => Some(0x5440u16),
0x580a => Some(0x5441u16),
0x57d6 => Some(0x5442u16),
0x57e3 => Some(0x5443u16),
0x580b => Some(0x5444u16),
0x5819 => Some(0x5445u16),
0x581d => Some(0x5446u16),
0x5872 => Some(0x5447u16),
0x5821 => Some(0x5448u16),
0x5862 => Some(0x5449u16),
0x584b => Some(0x544au16),
0x5870 => Some(0x544bu16),
0x6bc0 => Some(0x544cu16),
0x5852 => Some(0x544du16),
0x583d => Some(0x544eu16),
0x5879 => Some(0x544fu16),
0x5885 => Some(0x5450u16),
0x58b9 => Some(0x5451u16),
0x589f => Some(0x5452u16),
0x58ab => Some(0x5453u16),
0x58ba => Some(0x5454u16),
0x58de => Some(0x5455u16),
0x58bb => Some(0x5456u16),
0x58b8 => Some(0x5457u16),
0x58ae => Some(0x5458u16),
0x58c5 => Some(0x5459u16),
0x58d3 => Some(0x545au16),
0x58d1 => Some(0x545bu16),
0x58d7 => Some(0x545cu16),
0x58d9 => Some(0x545du16),
0x58d8 => Some(0x545eu16),
0x58e5 => Some(0x545fu16),
0x58dc => Some(0x5460u16),
0x58e4 => Some(0x5461u16),
0x58df => Some(0x5462u16),
0x58ef => Some(0x5463u16),
0x58fa => Some(0x5464u16),
0x58f9 => Some(0x5465u16),
0x58fb => Some(0x5466u16),
0x58fc => Some(0x5467u16),
0x58fd => Some(0x5468u16),
0x5902 => Some(0x5469u16),
0x590a => Some(0x546au16),
0x5910 => Some(0x546bu16),
0x591b => Some(0x546cu16),
0x68a6 => Some(0x546du16),
0x5925 => Some(0x546eu16),
0x592c => Some(0x546fu16),
0x592d => Some(0x5470u16),
0x5932 => Some(0x5471u16),
0x5938 => Some(0x5472u16),
0x593e => Some(0x5473u16),
0x7ad2 => Some(0x5474u16),
0x5955 => Some(0x5475u16),
0x5950 => Some(0x5476u16),
0x594e => Some(0x5477u16),
0x595a => Some(0x5478u16),
0x5958 => Some(0x5479u16),
0x5962 => Some(0x547au16),
0x5960 => Some(0x547bu16),
0x5967 => Some(0x547cu16),
0x596c => Some(0x547du16),
0x5969 => Some(0x547eu16),
0x5978 => Some(0x5521u16),
0x5981 => Some(0x5522u16),
0x599d => Some(0x5523u16),
0x4f5e => Some(0x5524u16),
0x4fab => Some(0x5525u16),
0x59a3 => Some(0x5526u16),
0x59b2 => Some(0x5527u16),
0x59c6 => Some(0x5528u16),
0x59e8 => Some(0x5529u16),
0x59dc => Some(0x552au16),
0x598d => Some(0x552bu16),
0x59d9 => Some(0x552cu16),
0x59da => Some(0x552du16),
0x5a25 => Some(0x552eu16),
0x5a1f => Some(0x552fu16),
0x5a11 => Some(0x5530u16),
0x5a1c => Some(0x5531u16),
0x5a09 => Some(0x5532u16),
0x5a1a => Some(0x5533u16),
0x5a40 => Some(0x5534u16),
0x5a6c => Some(0x5535u16),
0x5a49 => Some(0x5536u16),
0x5a35 => Some(0x5537u16),
0x5a36 => Some(0x5538u16),
0x5a62 => Some(0x5539u16),
0x5a6a => Some(0x553au16),
0x5a9a => Some(0x553bu16),
0x5abc => Some(0x553cu16),
0x5abe => Some(0x553du16),
0x5acb => Some(0x553eu16),
0x5ac2 => Some(0x553fu16),
0x5abd => Some(0x5540u16),
0x5ae3 => Some(0x5541u16),
0x5ad7 => Some(0x5542u16),
0x5ae6 => Some(0x5543u16),
0x5ae9 => Some(0x5544u16),
0x5ad6 => Some(0x5545u16),
0x5afa => Some(0x5546u16),
0x5afb => Some(0x5547u16),
0x5b0c => Some(0x5548u16),
0x5b0b => Some(0x5549u16),
0x5b16 => Some(0x554au16),
0x5b32 => Some(0x554bu16),
0x5ad0 => Some(0x554cu16),
0x5b2a => Some(0x554du16),
0x5b36 => Some(0x554eu16),
0x5b3e => Some(0x554fu16),
0x5b43 => Some(0x5550u16),
0x5b45 => Some(0x5551u16),
0x5b40 => Some(0x5552u16),
0x5b51 => Some(0x5553u16),
0x5b55 => Some(0x5554u16),
0x5b5a => Some(0x5555u16),
0x5b5b => Some(0x5556u16),
0x5b65 => Some(0x5557u16),
0x5b69 => Some(0x5558u16),
0x5b70 => Some(0x5559u16),
0x5b73 => Some(0x555au16),
0x5b75 => Some(0x555bu16),
0x5b78 => Some(0x555cu16),
0x6588 => Some(0x555du16),
0x5b7a => Some(0x555eu16),
0x5b80 => Some(0x555fu16),
0x5b83 => Some(0x5560u16),
0x5ba6 => Some(0x5561u16),
0x5bb8 => Some(0x5562u16),
0x5bc3 => Some(0x5563u16),
0x5bc7 => Some(0x5564u16),
0x5bc9 => Some(0x5565u16),
0x5bd4 => Some(0x5566u16),
0x5bd0 => Some(0x5567u16),
0x5be4 => Some(0x5568u16),
0x5be6 => Some(0x5569u16),
0x5be2 => Some(0x556au16),
0x5bde => Some(0x556bu16),
0x5be5 => Some(0x556cu16),
0x5beb => Some(0x556du16),
0x5bf0 => Some(0x556eu16),
0x5bf6 => Some(0x556fu16),
0x5bf3 => Some(0x5570u16),
0x5c05 => Some(0x5571u16),
0x5c07 => Some(0x5572u16),
0x5c08 => Some(0x5573u16),
0x5c0d => Some(0x5574u16),
0x5c13 => Some(0x5575u16),
0x5c20 => Some(0x5576u16),
0x5c22 => Some(0x5577u16),
0x5c28 => Some(0x5578u16),
0x5c38 => Some(0x5579u16),
0x5c39 => Some(0x557au16),
0x5c41 => Some(0x557bu16),
0x5c46 => Some(0x557cu16),
0x5c4e => Some(0x557du16),
0x5c53 => Some(0x557eu16),
0x5c50 => Some(0x5621u16),
0x5c4f => Some(0x5622u16),
0x5b71 => Some(0x5623u16),
0x5c6c => Some(0x5624u16),
0x5c6e => Some(0x5625u16),
0x4e62 => Some(0x5626u16),
0x5c76 => Some(0x5627u16),
0x5c79 => Some(0x5628u16),
0x5c8c => Some(0x5629u16),
0x5c91 => Some(0x562au16),
0x5c94 => Some(0x562bu16),
0x599b => Some(0x562cu16),
0x5cab => Some(0x562du16),
0x5cbb => Some(0x562eu16),
0x5cb6 => Some(0x562fu16),
0x5cbc => Some(0x5630u16),
0x5cb7 => Some(0x5631u16),
0x5cc5 => Some(0x5632u16),
0x5cbe => Some(0x5633u16),
0x5cc7 => Some(0x5634u16),
0x5cd9 => Some(0x5635u16),
0x5ce9 => Some(0x5636u16),
0x5cfd => Some(0x5637u16),
0x5cfa => Some(0x5638u16),
0x5ced => Some(0x5639u16),
0x5d8c => Some(0x563au16),
0x5cea => Some(0x563bu16),
0x5d0b => Some(0x563cu16),
0x5d15 => Some(0x563du16),
0x5d17 => Some(0x563eu16),
0x5d5c => Some(0x563fu16),
0x5d1f => Some(0x5640u16),
0x5d1b => Some(0x5641u16),
0x5d11 => Some(0x5642u16),
0x5d14 => Some(0x5643u16),
0x5d22 => Some(0x5644u16),
0x5d1a => Some(0x5645u16),
0x5d19 => Some(0x5646u16),
0x5d18 => Some(0x5647u16),
0x5d4c => Some(0x5648u16),
0x5d52 => Some(0x5649u16),
0x5d4e => Some(0x564au16),
0x5d4b => Some(0x564bu16),
0x5d6c => Some(0x564cu16),
0x5d73 => Some(0x564du16),
0x5d76 => Some(0x564eu16),
0x5d87 => Some(0x564fu16),
0x5d84 => Some(0x5650u16),
0x5d82 => Some(0x5651u16),
0x5da2 => Some(0x5652u16),
0x5d9d => Some(0x5653u16),
0x5dac => Some(0x5654u16),
0x5dae => Some(0x5655u16),
0x5dbd => Some(0x5656u16),
0x5d90 => Some(0x5657u16),
0x5db7 => Some(0x5658u16),
0x5dbc => Some(0x5659u16),
0x5dc9 => Some(0x565au16),
0x5dcd => Some(0x565bu16),
0x5dd3 => Some(0x565cu16),
0x5dd2 => Some(0x565du16),
0x5dd6 => Some(0x565eu16),
0x5ddb => Some(0x565fu16),
0x5deb => Some(0x5660u16),
0x5df2 => Some(0x5661u16),
0x5df5 => Some(0x5662u16),
0x5e0b => Some(0x5663u16),
0x5e1a => Some(0x5664u16),
0x5e19 => Some(0x5665u16),
0x5e11 => Some(0x5666u16),
0x5e1b => Some(0x5667u16),
0x5e36 => Some(0x5668u16),
0x5e37 => Some(0x5669u16),
0x5e44 => Some(0x566au16),
0x5e43 => Some(0x566bu16),
0x5e40 => Some(0x566cu16),
0x5e4e => Some(0x566du16),
0x5e57 => Some(0x566eu16),
0x5e54 => Some(0x566fu16),
0x5e5f => Some(0x5670u16),
0x5e62 => Some(0x5671u16),
0x5e64 => Some(0x5672u16),
0x5e47 => Some(0x5673u16),
0x5e75 => Some(0x5674u16),
0x5e76 => Some(0x5675u16),
0x5e7a => Some(0x5676u16),
0x9ebc => Some(0x5677u16),
0x5e7f => Some(0x5678u16),
0x5ea0 => Some(0x5679u16),
0x5ec1 => Some(0x567au16),
0x5ec2 => Some(0x567bu16),
0x5ec8 => Some(0x567cu16),
0x5ed0 => Some(0x567du16),
0x5ecf => Some(0x567eu16),
0x5ed6 => Some(0x5721u16),
0x5ee3 => Some(0x5722u16),
0x5edd => Some(0x5723u16),
0x5eda => Some(0x5724u16),
0x5edb => Some(0x5725u16),
0x5ee2 => Some(0x5726u16),
0x5ee1 => Some(0x5727u16),
0x5ee8 => Some(0x5728u16),
0x5ee9 => Some(0x5729u16),
0x5eec => Some(0x572au16),
0x5ef1 => Some(0x572bu16),
0x5ef3 => Some(0x572cu16),
0x5ef0 => Some(0x572du16),
0x5ef4 => Some(0x572eu16),
0x5ef8 => Some(0x572fu16),
0x5efe => Some(0x5730u16),
0x5f03 => Some(0x5731u16),
0x5f09 => Some(0x5732u16),
0x5f5d => Some(0x5733u16),
0x5f5c => Some(0x5734u16),
0x5f0b => Some(0x5735u16),
0x5f11 => Some(0x5736u16),
0x5f16 => Some(0x5737u16),
0x5f29 => Some(0x5738u16),
0x5f2d => Some(0x5739u16),
0x5f38 => Some(0x573au16),
0x5f41 => Some(0x573bu16),
0x5f48 => Some(0x573cu16),
0x5f4c => Some(0x573du16),
0x5f4e => Some(0x573eu16),
0x5f2f => Some(0x573fu16),
0x5f51 => Some(0x5740u16),
0x5f56 => Some(0x5741u16),
0x5f57 => Some(0x5742u16),
0x5f59 => Some(0x5743u16),
0x5f61 => Some(0x5744u16),
0x5f6d => Some(0x5745u16),
0x5f73 => Some(0x5746u16),
0x5f77 => Some(0x5747u16),
0x5f83 => Some(0x5748u16),
0x5f82 => Some(0x5749u16),
0x5f7f => Some(0x574au16),
0x5f8a => Some(0x574bu16),
0x5f88 => Some(0x574cu16),
0x5f91 => Some(0x574du16),
0x5f87 => Some(0x574eu16),
0x5f9e => Some(0x574fu16),
0x5f99 => Some(0x5750u16),
0x5f98 => Some(0x5751u16),
0x5fa0 => Some(0x5752u16),
0x5fa8 => Some(0x5753u16),
0x5fad => Some(0x5754u16),
0x5fbc => Some(0x5755u16),
0x5fd6 => Some(0x5756u16),
0x5ffb => Some(0x5757u16),
0x5fe4 => Some(0x5758u16),
0x5ff8 => Some(0x5759u16),
0x5ff1 => Some(0x575au16),
0x5fdd => Some(0x575bu16),
0x60b3 => Some(0x575cu16),
0x5fff => Some(0x575du16),
0x6021 => Some(0x575eu16),
0x6060 => Some(0x575fu16),
0x6019 => Some(0x5760u16),
0x6010 => Some(0x5761u16),
0x6029 => Some(0x5762u16),
0x600e => Some(0x5763u16),
0x6031 => Some(0x5764u16),
0x601b => Some(0x5765u16),
0x6015 => Some(0x5766u16),
0x602b => Some(0x5767u16),
0x6026 => Some(0x5768u16),
0x600f => Some(0x5769u16),
0x603a => Some(0x576au16),
0x605a => Some(0x576bu16),
0x6041 => Some(0x576cu16),
0x606a => Some(0x576du16),
0x6077 => Some(0x576eu16),
0x605f => Some(0x576fu16),
0x604a => Some(0x5770u16),
0x6046 => Some(0x5771u16),
0x604d => Some(0x5772u16),
0x6063 => Some(0x5773u16),
0x6043 => Some(0x5774u16),
0x6064 => Some(0x5775u16),
0x6042 => Some(0x5776u16),
0x606c => Some(0x5777u16),
0x606b => Some(0x5778u16),
0x6059 => Some(0x5779u16),
0x6081 => Some(0x577au16),
0x608d => Some(0x577bu16),
0x60e7 => Some(0x577cu16),
0x6083 => Some(0x577du16),
0x609a => Some(0x577eu16),
0x6084 => Some(0x5821u16),
0x609b => Some(0x5822u16),
0x6096 => Some(0x5823u16),
0x6097 => Some(0x5824u16),
0x6092 => Some(0x5825u16),
0x60a7 => Some(0x5826u16),
0x608b => Some(0x5827u16),
0x60e1 => Some(0x5828u16),
0x60b8 => Some(0x5829u16),
0x60e0 => Some(0x582au16),
0x60d3 => Some(0x582bu16),
0x60b4 => Some(0x582cu16),
0x5ff0 => Some(0x582du16),
0x60bd => Some(0x582eu16),
0x60c6 => Some(0x582fu16),
0x60b5 => Some(0x5830u16),
0x60d8 => Some(0x5831u16),
0x614d => Some(0x5832u16),
0x6115 => Some(0x5833u16),
0x6106 => Some(0x5834u16),
0x60f6 => Some(0x5835u16),
0x60f7 => Some(0x5836u16),
0x6100 => Some(0x5837u16),
0x60f4 => Some(0x5838u16),
0x60fa => Some(0x5839u16),
0x6103 => Some(0x583au16),
0x6121 => Some(0x583bu16),
0x60fb => Some(0x583cu16),
0x60f1 => Some(0x583du16),
0x610d => Some(0x583eu16),
0x610e => Some(0x583fu16),
0x6147 => Some(0x5840u16),
0x613e => Some(0x5841u16),
0x6128 => Some(0x5842u16),
0x6127 => Some(0x5843u16),
0x614a => Some(0x5844u16),
0x613f => Some(0x5845u16),
0x613c => Some(0x5846u16),
0x612c => Some(0x5847u16),
0x6134 => Some(0x5848u16),
0x613d => Some(0x5849u16),
0x6142 => Some(0x584au16),
0x6144 => Some(0x584bu16),
0x6173 => Some(0x584cu16),
0x6177 => Some(0x584du16),
0x6158 => Some(0x584eu16),
0x6159 => Some(0x584fu16),
0x615a => Some(0x5850u16),
0x616b => Some(0x5851u16),
0x6174 => Some(0x5852u16),
0x616f => Some(0x5853u16),
0x6165 => Some(0x5854u16),
0x6171 => Some(0x5855u16),
0x615f => Some(0x5856u16),
0x615d => Some(0x5857u16),
0x6153 => Some(0x5858u16),
0x6175 => Some(0x5859u16),
0x6199 => Some(0x585au16),
0x6196 => Some(0x585bu16),
0x6187 => Some(0x585cu16),
0x61ac => Some(0x585du16),
0x6194 => Some(0x585eu16),
0x619a => Some(0x585fu16),
0x618a => Some(0x5860u16),
0x6191 => Some(0x5861u16),
0x61ab => Some(0x5862u16),
0x61ae => Some(0x5863u16),
0x61cc => Some(0x5864u16),
0x61ca => Some(0x5865u16),
0x61c9 => Some(0x5866u16),
0x61f7 => Some(0x5867u16),
0x61c8 => Some(0x5868u16),
0x61c3 => Some(0x5869u16),
0x61c6 => Some(0x586au16),
0x61ba => Some(0x586bu16),
0x61cb => Some(0x586cu16),
0x7f79 => Some(0x586du16),
0x61cd => Some(0x586eu16),
0x61e6 => Some(0x586fu16),
0x61e3 => Some(0x5870u16),
0x61f6 => Some(0x5871u16),
0x61fa => Some(0x5872u16),
0x61f4 => Some(0x5873u16),
0x61ff => Some(0x5874u16),
0x61fd => Some(0x5875u16),
0x61fc => Some(0x5876u16),
0x61fe => Some(0x5877u16),
0x6200 => Some(0x5878u16),
0x6208 => Some(0x5879u16),
0x6209 => Some(0x587au16),
0x620d => Some(0x587bu16),
0x620c => Some(0x587cu16),
0x6214 => Some(0x587du16),
0x621b => Some(0x587eu16),
0x621e => Some(0x5921u16),
0x6221 => Some(0x5922u16),
0x622a => Some(0x5923u16),
0x622e => Some(0x5924u16),
0x6230 => Some(0x5925u16),
0x6232 => Some(0x5926u16),
0x6233 => Some(0x5927u16),
0x6241 => Some(0x5928u16),
0x624e => Some(0x5929u16),
0x625e => Some(0x592au16),
0x6263 => Some(0x592bu16),
0x625b => Some(0x592cu16),
0x6260 => Some(0x592du16),
0x6268 => Some(0x592eu16),
0x627c => Some(0x592fu16),
0x6282 => Some(0x5930u16),
0x6289 => Some(0x5931u16),
0x627e => Some(0x5932u16),
0x6292 => Some(0x5933u16),
0x6293 => Some(0x5934u16),
0x6296 => Some(0x5935u16),
0x62d4 => Some(0x5936u16),
0x6283 => Some(0x5937u16),
0x6294 => Some(0x5938u16),
0x62d7 => Some(0x5939u16),
0x62d1 => Some(0x593au16),
0x62bb => Some(0x593bu16),
0x62cf => Some(0x593cu16),
0x62ff => Some(0x593du16),
0x62c6 => Some(0x593eu16),
0x64d4 => Some(0x593fu16),
0x62c8 => Some(0x5940u16),
0x62dc => Some(0x5941u16),
0x62cc => Some(0x5942u16),
0x62ca => Some(0x5943u16),
0x62c2 => Some(0x5944u16),
0x62c7 => Some(0x5945u16),
0x629b => Some(0x5946u16),
0x62c9 => Some(0x5947u16),
0x630c => Some(0x5948u16),
0x62ee => Some(0x5949u16),
0x62f1 => Some(0x594au16),
0x6327 => Some(0x594bu16),
0x6302 => Some(0x594cu16),
0x6308 => Some(0x594du16),
0x62ef => Some(0x594eu16),
0x62f5 => Some(0x594fu16),
0x6350 => Some(0x5950u16),
0x633e => Some(0x5951u16),
0x634d => Some(0x5952u16),
0x641c => Some(0x5953u16),
0x634f => Some(0x5954u16),
0x6396 => Some(0x5955u16),
0x638e => Some(0x5956u16),
0x6380 => Some(0x5957u16),
0x63ab => Some(0x5958u16),
0x6376 => Some(0x5959u16),
0x63a3 => Some(0x595au16),
0x638f => Some(0x595bu16),
0x6389 => Some(0x595cu16),
0x639f => Some(0x595du16),
0x63b5 => Some(0x595eu16),
0x636b => Some(0x595fu16),
0x6369 => Some(0x5960u16),
0x63be => Some(0x5961u16),
0x63e9 => Some(0x5962u16),
0x63c0 => Some(0x5963u16),
0x63c6 => Some(0x5964u16),
0x63e3 => Some(0x5965u16),
0x63c9 => Some(0x5966u16),
0x63d2 => Some(0x5967u16),
0x63f6 => Some(0x5968u16),
0x63c4 => Some(0x5969u16),
0x6416 => Some(0x596au16),
0x6434 => Some(0x596bu16),
0x6406 => Some(0x596cu16),
0x6413 => Some(0x596du16),
0x6426 => Some(0x596eu16),
0x6436 => Some(0x596fu16),
0x651d => Some(0x5970u16),
0x6417 => Some(0x5971u16),
0x6428 => Some(0x5972u16),
0x640f => Some(0x5973u16),
0x6467 => Some(0x5974u16),
0x646f => Some(0x5975u16),
0x6476 => Some(0x5976u16),
0x644e => Some(0x5977u16),
0x652a => Some(0x5978u16),
0x6495 => Some(0x5979u16),
0x6493 => Some(0x597au16),
0x64a5 => Some(0x597bu16),
0x64a9 => Some(0x597cu16),
0x6488 => Some(0x597du16),
0x64bc => Some(0x597eu16),
0x64da => Some(0x5a21u16),
0x64d2 => Some(0x5a22u16),
0x64c5 => Some(0x5a23u16),
0x64c7 => Some(0x5a24u16),
0x64bb => Some(0x5a25u16),
0x64d8 => Some(0x5a26u16),
0x64c2 => Some(0x5a27u16),
0x64f1 => Some(0x5a28u16),
0x64e7 => Some(0x5a29u16),
0x8209 => Some(0x5a2au16),
0x64e0 => Some(0x5a2bu16),
0x64e1 => Some(0x5a2cu16),
0x62ac => Some(0x5a2du16),
0x64e3 => Some(0x5a2eu16),
0x64ef => Some(0x5a2fu16),
0x652c => Some(0x5a30u16),
0x64f6 => Some(0x5a31u16),
0x64f4 => Some(0x5a32u16),
0x64f2 => Some(0x5a33u16),
0x64fa => Some(0x5a34u16),
0x6500 => Some(0x5a35u16),
0x64fd => Some(0x5a36u16),
0x6518 => Some(0x5a37u16),
0x651c => Some(0x5a38u16),
0x6505 => Some(0x5a39u16),
0x6524 => Some(0x5a3au16),
0x6523 => Some(0x5a3bu16),
0x652b => Some(0x5a3cu16),
0x6534 => Some(0x5a3du16),
0x6535 => Some(0x5a3eu16),
0x6537 => Some(0x5a3fu16),
0x6536 => Some(0x5a40u16),
0x6538 => Some(0x5a41u16),
0x754b => Some(0x5a42u16),
0x6548 => Some(0x5a43u16),
0x6556 => Some(0x5a44u16),
0x6555 => Some(0x5a45u16),
0x654d => Some(0x5a46u16),
0x6558 => Some(0x5a47u16),
0x655e => Some(0x5a48u16),
0x655d => Some(0x5a49u16),
0x6572 => Some(0x5a4au16),
0x6578 => Some(0x5a4bu16),
0x6582 => Some(0x5a4cu16),
0x6583 => Some(0x5a4du16),
0x8b8a => Some(0x5a4eu16),
0x659b => Some(0x5a4fu16),
0x659f => Some(0x5a50u16),
0x65ab => Some(0x5a51u16),
0x65b7 => Some(0x5a52u16),
0x65c3 => Some(0x5a53u16),
0x65c6 => Some(0x5a54u16),
0x65c1 => Some(0x5a55u16),
0x65c4 => Some(0x5a56u16),
0x65cc => Some(0x5a57u16),
0x65d2 => Some(0x5a58u16),
0x65db => Some(0x5a59u16),
0x65d9 => Some(0x5a5au16),
0x65e0 => Some(0x5a5bu16),
0x65e1 => Some(0x5a5cu16),
0x65f1 => Some(0x5a5du16),
0x6772 => Some(0x5a5eu16),
0x660a => Some(0x5a5fu16),
0x6603 => Some(0x5a60u16),
0x65fb => Some(0x5a61u16),
0x6773 => Some(0x5a62u16),
0x6635 => Some(0x5a63u16),
0x6636 => Some(0x5a64u16),
0x6634 => Some(0x5a65u16),
0x661c => Some(0x5a66u16),
0x664f => Some(0x5a67u16),
0x6644 => Some(0x5a68u16),
0x6649 => Some(0x5a69u16),
0x6641 => Some(0x5a6au16),
0x665e => Some(0x5a6bu16),
0x665d => Some(0x5a6cu16),
0x6664 => Some(0x5a6du16),
0x6667 => Some(0x5a6eu16),
0x6668 => Some(0x5a6fu16),
0x665f => Some(0x5a70u16),
0x6662 => Some(0x5a71u16),
0x6670 => Some(0x5a72u16),
0x6683 => Some(0x5a73u16),
0x6688 => Some(0x5a74u16),
0x668e => Some(0x5a75u16),
0x6689 => Some(0x5a76u16),
0x6684 => Some(0x5a77u16),
0x6698 => Some(0x5a78u16),
0x669d => Some(0x5a79u16),
0x66c1 => Some(0x5a7au16),
0x66b9 => Some(0x5a7bu16),
0x66c9 => Some(0x5a7cu16),
0x66be => Some(0x5a7du16),
0x66bc => Some(0x5a7eu16),
0x66c4 => Some(0x5b21u16),
0x66b8 => Some(0x5b22u16),
0x66d6 => Some(0x5b23u16),
0x66da => Some(0x5b24u16),
0x66e0 => Some(0x5b25u16),
0x663f => Some(0x5b26u16),
0x66e6 => Some(0x5b27u16),
0x66e9 => Some(0x5b28u16),
0x66f0 => Some(0x5b29u16),
0x66f5 => Some(0x5b2au16),
0x66f7 => Some(0x5b2bu16),
0x670f => Some(0x5b2cu16),
0x6716 => Some(0x5b2du16),
0x671e => Some(0x5b2eu16),
0x6726 => Some(0x5b2fu16),
0x6727 => Some(0x5b30u16),
0x9738 => Some(0x5b31u16),
0x672e => Some(0x5b32u16),
0x673f => Some(0x5b33u16),
0x6736 => Some(0x5b34u16),
0x6741 => Some(0x5b35u16),
0x6738 => Some(0x5b36u16),
0x6737 => Some(0x5b37u16),
0x6746 => Some(0x5b38u16),
0x675e => Some(0x5b39u16),
0x6760 => Some(0x5b3au16),
0x6759 => Some(0x5b3bu16),
0x6763 => Some(0x5b3cu16),
0x6764 => Some(0x5b3du16),
0x6789 => Some(0x5b3eu16),
0x6770 => Some(0x5b3fu16),
0x67a9 => Some(0x5b40u16),
0x677c => Some(0x5b41u16),
0x676a => Some(0x5b42u16),
0x678c => Some(0x5b43u16),
0x678b => Some(0x5b44u16),
0x67a6 => Some(0x5b45u16),
0x67a1 => Some(0x5b46u16),
0x6785 => Some(0x5b47u16),
0x67b7 => Some(0x5b48u16),
0x67ef => Some(0x5b49u16),
0x67b4 => Some(0x5b4au16),
0x67ec => Some(0x5b4bu16),
0x67b3 => Some(0x5b4cu16),
0x67e9 => Some(0x5b4du16),
0x67b8 => Some(0x5b4eu16),
0x67e4 => Some(0x5b4fu16),
0x67de => Some(0x5b50u16),
0x67dd => Some(0x5b51u16),
0x67e2 => Some(0x5b52u16),
0x67ee => Some(0x5b53u16),
0x67b9 => Some(0x5b54u16),
0x67ce => Some(0x5b55u16),
0x67c6 => Some(0x5b56u16),
0x67e7 => Some(0x5b57u16),
0x6a9c => Some(0x5b58u16),
0x681e => Some(0x5b59u16),
0x6846 => Some(0x5b5au16),
0x6829 => Some(0x5b5bu16),
0x6840 => Some(0x5b5cu16),
0x684d => Some(0x5b5du16),
0x6832 => Some(0x5b5eu16),
0x684e => Some(0x5b5fu16),
0x68b3 => Some(0x5b60u16),
0x682b => Some(0x5b61u16),
0x6859 => Some(0x5b62u16),
0x6863 => Some(0x5b63u16),
0x6877 => Some(0x5b64u16),
0x687f => Some(0x5b65u16),
0x689f => Some(0x5b66u16),
0x688f => Some(0x5b67u16),
0x68ad => Some(0x5b68u16),
0x6894 => Some(0x5b69u16),
0x689d => Some(0x5b6au16),
0x689b => Some(0x5b6bu16),
0x6883 => Some(0x5b6cu16),
0x6aae => Some(0x5b6du16),
0x68b9 => Some(0x5b6eu16),
0x6874 => Some(0x5b6fu16),
0x68b5 => Some(0x5b70u16),
0x68a0 => Some(0x5b71u16),
0x68ba => Some(0x5b72u16),
0x690f => Some(0x5b73u16),
0x688d => Some(0x5b74u16),
0x687e => Some(0x5b75u16),
0x6901 => Some(0x5b76u16),
0x68ca => Some(0x5b77u16),
0x6908 => Some(0x5b78u16),
0x68d8 => Some(0x5b79u16),
0x6922 => Some(0x5b7au16),
0x6926 => Some(0x5b7bu16),
0x68e1 => Some(0x5b7cu16),
0x690c => Some(0x5b7du16),
0x68cd => Some(0x5b7eu16),
0x68d4 => Some(0x5c21u16),
0x68e7 => Some(0x5c22u16),
0x68d5 => Some(0x5c23u16),
0x6936 => Some(0x5c24u16),
0x6912 => Some(0x5c25u16),
0x6904 => Some(0x5c26u16),
0x68d7 => Some(0x5c27u16),
0x68e3 => Some(0x5c28u16),
0x6925 => Some(0x5c29u16),
0x68f9 => Some(0x5c2au16),
0x68e0 => Some(0x5c2bu16),
0x68ef => Some(0x5c2cu16),
0x6928 => Some(0x5c2du16),
0x692a => Some(0x5c2eu16),
0x691a => Some(0x5c2fu16),
0x6923 => Some(0x5c30u16),
0x6921 => Some(0x5c31u16),
0x68c6 => Some(0x5c32u16),
0x6979 => Some(0x5c33u16),
0x6977 => Some(0x5c34u16),
0x695c => Some(0x5c35u16),
0x6978 => Some(0x5c36u16),
0x696b => Some(0x5c37u16),
0x6954 => Some(0x5c38u16),
0x697e => Some(0x5c39u16),
0x696e => Some(0x5c3au16),
0x6939 => Some(0x5c3bu16),
0x6974 => Some(0x5c3cu16),
0x693d => Some(0x5c3du16),
0x6959 => Some(0x5c3eu16),
0x6930 => Some(0x5c3fu16),
0x6961 => Some(0x5c40u16),
0x695e => Some(0x5c41u16),
0x695d => Some(0x5c42u16),
0x6981 => Some(0x5c43u16),
0x696a => Some(0x5c44u16),
0x69b2 => Some(0x5c45u16),
0x69ae => Some(0x5c46u16),
0x69d0 => Some(0x5c47u16),
0x69bf => Some(0x5c48u16),
0x69c1 => Some(0x5c49u16),
0x69d3 => Some(0x5c4au16),
0x69be => Some(0x5c4bu16),
0x69ce => Some(0x5c4cu16),
0x5be8 => Some(0x5c4du16),
0x69ca => Some(0x5c4eu16),
0x69dd => Some(0x5c4fu16),
0x69bb => Some(0x5c50u16),
0x69c3 => Some(0x5c51u16),
0x69a7 => Some(0x5c52u16),
0x6a2e => Some(0x5c53u16),
0x6991 => Some(0x5c54u16),
0x69a0 => Some(0x5c55u16),
0x699c => Some(0x5c56u16),
0x6995 => Some(0x5c57u16),
0x69b4 => Some(0x5c58u16),
0x69de => Some(0x5c59u16),
0x69e8 => Some(0x5c5au16),
0x6a02 => Some(0x5c5bu16),
0x6a1b => Some(0x5c5cu16),
0x69ff => Some(0x5c5du16),
0x6b0a => Some(0x5c5eu16),
0x69f9 => Some(0x5c5fu16),
0x69f2 => Some(0x5c60u16),
0x69e7 => Some(0x5c61u16),
0x6a05 => Some(0x5c62u16),
0x69b1 => Some(0x5c63u16),
0x6a1e => Some(0x5c64u16),
0x69ed => Some(0x5c65u16),
0x6a14 => Some(0x5c66u16),
0x69eb => Some(0x5c67u16),
0x6a0a => Some(0x5c68u16),
0x6a12 => Some(0x5c69u16),
0x6ac1 => Some(0x5c6au16),
0x6a23 => Some(0x5c6bu16),
0x6a13 => Some(0x5c6cu16),
0x6a44 => Some(0x5c6du16),
0x6a0c => Some(0x5c6eu16),
0x6a72 => Some(0x5c6fu16),
0x6a36 => Some(0x5c70u16),
0x6a78 => Some(0x5c71u16),
0x6a47 => Some(0x5c72u16),
0x6a62 => Some(0x5c73u16),
0x6a59 => Some(0x5c74u16),
0x6a66 => Some(0x5c75u16),
0x6a48 => Some(0x5c76u16),
0x6a38 => Some(0x5c77u16),
0x6a22 => Some(0x5c78u16),
0x6a90 => Some(0x5c79u16),
0x6a8d => Some(0x5c7au16),
0x6aa0 => Some(0x5c7bu16),
0x6a84 => Some(0x5c7cu16),
0x6aa2 => Some(0x5c7du16),
0x6aa3 => Some(0x5c7eu16),
0x6a97 => Some(0x5d21u16),
0x8617 => Some(0x5d22u16),
0x6abb => Some(0x5d23u16),
0x6ac3 => Some(0x5d24u16),
0x6ac2 => Some(0x5d25u16),
0x6ab8 => Some(0x5d26u16),
0x6ab3 => Some(0x5d27u16),
0x6aac => Some(0x5d28u16),
0x6ade => Some(0x5d29u16),
0x6ad1 => Some(0x5d2au16),
0x6adf => Some(0x5d2bu16),
0x6aaa => Some(0x5d2cu16),
0x6ada => Some(0x5d2du16),
0x6aea => Some(0x5d2eu16),
0x6afb => Some(0x5d2fu16),
0x6b05 => Some(0x5d30u16),
0x8616 => Some(0x5d31u16),
0x6afa => Some(0x5d32u16),
0x6b12 => Some(0x5d33u16),
0x6b16 => Some(0x5d34u16),
0x9b31 => Some(0x5d35u16),
0x6b1f => Some(0x5d36u16),
0x6b38 => Some(0x5d37u16),
0x6b37 => Some(0x5d38u16),
0x76dc => Some(0x5d39u16),
0x6b39 => Some(0x5d3au16),
0x98ee => Some(0x5d3bu16),
0x6b47 => Some(0x5d3cu16),
0x6b43 => Some(0x5d3du16),
0x6b49 => Some(0x5d3eu16),
0x6b50 => Some(0x5d3fu16),
0x6b59 => Some(0x5d40u16),
0x6b54 => Some(0x5d41u16),
0x6b5b => Some(0x5d42u16),
0x6b5f => Some(0x5d43u16),
0x6b61 => Some(0x5d44u16),
0x6b78 => Some(0x5d45u16),
0x6b79 => Some(0x5d46u16),
0x6b7f => Some(0x5d47u16),
0x6b80 => Some(0x5d48u16),
0x6b84 => Some(0x5d49u16),
0x6b83 => Some(0x5d4au16),
0x6b8d => Some(0x5d4bu16),
0x6b98 => Some(0x5d4cu16),
0x6b95 => Some(0x5d4du16),
0x6b9e => Some(0x5d4eu16),
0x6ba4 => Some(0x5d4fu16),
0x6baa => Some(0x5d50u16),
0x6bab => Some(0x5d51u16),
0x6baf => Some(0x5d52u16),
0x6bb2 => Some(0x5d53u16),
0x6bb1 => Some(0x5d54u16),
0x6bb3 => Some(0x5d55u16),
0x6bb7 => Some(0x5d56u16),
0x6bbc => Some(0x5d57u16),
0x6bc6 => Some(0x5d58u16),
0x6bcb => Some(0x5d59u16),
0x6bd3 => Some(0x5d5au16),
0x6bdf => Some(0x5d5bu16),
0x6bec => Some(0x5d5cu16),
0x6beb => Some(0x5d5du16),
0x6bf3 => Some(0x5d5eu16),
0x6bef => Some(0x5d5fu16),
0x9ebe => Some(0x5d60u16),
0x6c08 => Some(0x5d61u16),
0x6c13 => Some(0x5d62u16),
0x6c14 => Some(0x5d63u16),
0x6c1b => Some(0x5d64u16),
0x6c24 => Some(0x5d65u16),
0x6c23 => Some(0x5d66u16),
0x6c5e => Some(0x5d67u16),
0x6c55 => Some(0x5d68u16),
0x6c62 => Some(0x5d69u16),
0x6c6a => Some(0x5d6au16),
0x6c82 => Some(0x5d6bu16),
0x6c8d => Some(0x5d6cu16),
0x6c9a => Some(0x5d6du16),
0x6c81 => Some(0x5d6eu16),
0x6c9b => Some(0x5d6fu16),
0x6c7e => Some(0x5d70u16),
0x6c68 => Some(0x5d71u16),
0x6c73 => Some(0x5d72u16),
0x6c92 => Some(0x5d73u16),
0x6c90 => Some(0x5d74u16),
0x6cc4 => Some(0x5d75u16),
0x6cf1 => Some(0x5d76u16),
0x6cd3 => Some(0x5d77u16),
0x6cbd => Some(0x5d78u16),
0x6cd7 => Some(0x5d79u16),
0x6cc5 => Some(0x5d7au16),
0x6cdd => Some(0x5d7bu16),
0x6cae => Some(0x5d7cu16),
0x6cb1 => Some(0x5d7du16),
0x6cbe => Some(0x5d7eu16),
0x6cba => Some(0x5e21u16),
0x6cdb => Some(0x5e22u16),
0x6cef => Some(0x5e23u16),
0x6cd9 => Some(0x5e24u16),
0x6cea => Some(0x5e25u16),
0x6d1f => Some(0x5e26u16),
0x884d => Some(0x5e27u16),
0x6d36 => Some(0x5e28u16),
0x6d2b => Some(0x5e29u16),
0x6d3d => Some(0x5e2au16),
0x6d38 => Some(0x5e2bu16),
0x6d19 => Some(0x5e2cu16),
0x6d35 => Some(0x5e2du16),
0x6d33 => Some(0x5e2eu16),
0x6d12 => Some(0x5e2fu16),
0x6d0c => Some(0x5e30u16),
0x6d63 => Some(0x5e31u16),
0x6d93 => Some(0x5e32u16),
0x6d64 => Some(0x5e33u16),
0x6d5a => Some(0x5e34u16),
0x6d79 => Some(0x5e35u16),
0x6d59 => Some(0x5e36u16),
0x6d8e => Some(0x5e37u16),
0x6d95 => Some(0x5e38u16),
0x6fe4 => Some(0x5e39u16),
0x6d85 => Some(0x5e3au16),
0x6df9 => Some(0x5e3bu16),
0x6e15 => Some(0x5e3cu16),
0x6e0a => Some(0x5e3du16),
0x6db5 => Some(0x5e3eu16),
0x6dc7 => Some(0x5e3fu16),
0x6de6 => Some(0x5e40u16),
0x6db8 => Some(0x5e41u16),
0x6dc6 => Some(0x5e42u16),
0x6dec => Some(0x5e43u16),
0x6dde => Some(0x5e44u16),
0x6dcc => Some(0x5e45u16),
0x6de8 => Some(0x5e46u16),
0x6dd2 => Some(0x5e47u16),
0x6dc5 => Some(0x5e48u16),
0x6dfa => Some(0x5e49u16),
0x6dd9 => Some(0x5e4au16),
0x6de4 => Some(0x5e4bu16),
0x6dd5 => Some(0x5e4cu16),
0x6dea => Some(0x5e4du16),
0x6dee => Some(0x5e4eu16),
0x6e2d => Some(0x5e4fu16),
0x6e6e => Some(0x5e50u16),
0x6e2e => Some(0x5e51u16),
0x6e19 => Some(0x5e52u16),
0x6e72 => Some(0x5e53u16),
0x6e5f => Some(0x5e54u16),
0x6e3e => Some(0x5e55u16),
0x6e23 => Some(0x5e56u16),
0x6e6b => Some(0x5e57u16),
0x6e2b => Some(0x5e58u16),
0x6e76 => Some(0x5e59u16),
0x6e4d => Some(0x5e5au16),
0x6e1f => Some(0x5e5bu16),
0x6e43 => Some(0x5e5cu16),
0x6e3a => Some(0x5e5du16),
0x6e4e => Some(0x5e5eu16),
0x6e24 => Some(0x5e5fu16),
0x6eff => Some(0x5e60u16),
0x6e1d => Some(0x5e61u16),
0x6e38 => Some(0x5e62u16),
0x6e82 => Some(0x5e63u16),
0x6eaa => Some(0x5e64u16),
0x6e98 => Some(0x5e65u16),
0x6ec9 => Some(0x5e66u16),
0x6eb7 => Some(0x5e67u16),
0x6ed3 => Some(0x5e68u16),
0x6ebd => Some(0x5e69u16),
0x6eaf => Some(0x5e6au16),
0x6ec4 => Some(0x5e6bu16),
0x6eb2 => Some(0x5e6cu16),
0x6ed4 => Some(0x5e6du16),
0x6ed5 => Some(0x5e6eu16),
0x6e8f => Some(0x5e6fu16),
0x6ea5 => Some(0x5e70u16),
0x6ec2 => Some(0x5e71u16),
0x6e9f => Some(0x5e72u16),
0x6f41 => Some(0x5e73u16),
0x6f11 => Some(0x5e74u16),
0x704c => Some(0x5e75u16),
0x6eec => Some(0x5e76u16),
0x6ef8 => Some(0x5e77u16),
0x6efe => Some(0x5e78u16),
0x6f3f => Some(0x5e79u16),
0x6ef2 => Some(0x5e7au16),
0x6f31 => Some(0x5e7bu16),
0x6eef => Some(0x5e7cu16),
0x6f32 => Some(0x5e7du16),
0x6ecc => Some(0x5e7eu16),
0x6f3e => Some(0x5f21u16),
0x6f13 => Some(0x5f22u16),
0x6ef7 => Some(0x5f23u16),
0x6f86 => Some(0x5f24u16),
0x6f7a => Some(0x5f25u16),
0x6f78 => Some(0x5f26u16),
0x6f81 => Some(0x5f27u16),
0x6f80 => Some(0x5f28u16),
0x6f6f => Some(0x5f29u16),
0x6f5b => Some(0x5f2au16),
0x6ff3 => Some(0x5f2bu16),
0x6f6d => Some(0x5f2cu16),
0x6f82 => Some(0x5f2du16),
0x6f7c => Some(0x5f2eu16),
0x6f58 => Some(0x5f2fu16),
0x6f8e => Some(0x5f30u16),
0x6f91 => Some(0x5f31u16),
0x6fc2 => Some(0x5f32u16),
0x6f66 => Some(0x5f33u16),
0x6fb3 => Some(0x5f34u16),
0x6fa3 => Some(0x5f35u16),
0x6fa1 => Some(0x5f36u16),
0x6fa4 => Some(0x5f37u16),
0x6fb9 => Some(0x5f38u16),
0x6fc6 => Some(0x5f39u16),
0x6faa => Some(0x5f3au16),
0x6fdf => Some(0x5f3bu16),
0x6fd5 => Some(0x5f3cu16),
0x6fec => Some(0x5f3du16),
0x6fd4 => Some(0x5f3eu16),
0x6fd8 => Some(0x5f3fu16),
0x6ff1 => Some(0x5f40u16),
0x6fee => Some(0x5f41u16),
0x6fdb => Some(0x5f42u16),
0x7009 => Some(0x5f43u16),
0x700b => Some(0x5f44u16),
0x6ffa => Some(0x5f45u16),
0x7011 => Some(0x5f46u16),
0x7001 => Some(0x5f47u16),
0x700f => Some(0x5f48u16),
0x6ffe => Some(0x5f49u16),
0x701b => Some(0x5f4au16),
0x701a => Some(0x5f4bu16),
0x6f74 => Some(0x5f4cu16),
0x701d => Some(0x5f4du16),
0x7018 => Some(0x5f4eu16),
0x701f => Some(0x5f4fu16),
0x7030 => Some(0x5f50u16),
0x703e => Some(0x5f51u16),
0x7032 => Some(0x5f52u16),
0x7051 => Some(0x5f53u16),
0x7063 => Some(0x5f54u16),
0x7099 => Some(0x5f55u16),
0x7092 => Some(0x5f56u16),
0x70af => Some(0x5f57u16),
0x70f1 => Some(0x5f58u16),
0x70ac => Some(0x5f59u16),
0x70b8 => Some(0x5f5au16),
0x70b3 => Some(0x5f5bu16),
0x70ae => Some(0x5f5cu16),
0x70df => Some(0x5f5du16),
0x70cb => Some(0x5f5eu16),
0x70dd => Some(0x5f5fu16),
0x70d9 => Some(0x5f60u16),
0x7109 => Some(0x5f61u16),
0x70fd => Some(0x5f62u16),
0x711c => Some(0x5f63u16),
0x7119 => Some(0x5f64u16),
0x7165 => Some(0x5f65u16),
0x7155 => Some(0x5f66u16),
0x7188 => Some(0x5f67u16),
0x7166 => Some(0x5f68u16),
0x7162 => Some(0x5f69u16),
0x714c => Some(0x5f6au16),
0x7156 => Some(0x5f6bu16),
0x716c => Some(0x5f6cu16),
0x718f => Some(0x5f6du16),
0x71fb => Some(0x5f6eu16),
0x7184 => Some(0x5f6fu16),
0x7195 => Some(0x5f70u16),
0x71a8 => Some(0x5f71u16),
0x71ac => Some(0x5f72u16),
0x71d7 => Some(0x5f73u16),
0x71b9 => Some(0x5f74u16),
0x71be => Some(0x5f75u16),
0x71d2 => Some(0x5f76u16),
0x71c9 => Some(0x5f77u16),
0x71d4 => Some(0x5f78u16),
0x71ce => Some(0x5f79u16),
0x71e0 => Some(0x5f7au16),
0x71ec => Some(0x5f7bu16),
0x71e7 => Some(0x5f7cu16),
0x71f5 => Some(0x5f7du16),
0x71fc => Some(0x5f7eu16),
0x71f9 => Some(0x6021u16),
0x71ff => Some(0x6022u16),
0x720d => Some(0x6023u16),
0x7210 => Some(0x6024u16),
0x721b => Some(0x6025u16),
0x7228 => Some(0x6026u16),
0x722d => Some(0x6027u16),
0x722c => Some(0x6028u16),
0x7230 => Some(0x6029u16),
0x7232 => Some(0x602au16),
0x723b => Some(0x602bu16),
0x723c => Some(0x602cu16),
0x723f => Some(0x602du16),
0x7240 => Some(0x602eu16),
0x7246 => Some(0x602fu16),
0x724b => Some(0x6030u16),
0x7258 => Some(0x6031u16),
0x7274 => Some(0x6032u16),
0x727e => Some(0x6033u16),
0x7282 => Some(0x6034u16),
0x7281 => Some(0x6035u16),
0x7287 => Some(0x6036u16),
0x7292 => Some(0x6037u16),
0x7296 => Some(0x6038u16),
0x72a2 => Some(0x6039u16),
0x72a7 => Some(0x603au16),
0x72b9 => Some(0x603bu16),
0x72b2 => Some(0x603cu16),
0x72c3 => Some(0x603du16),
0x72c6 => Some(0x603eu16),
0x72c4 => Some(0x603fu16),
0x72ce => Some(0x6040u16),
0x72d2 => Some(0x6041u16),
0x72e2 => Some(0x6042u16),
0x72e0 => Some(0x6043u16),
0x72e1 => Some(0x6044u16),
0x72f9 => Some(0x6045u16),
0x72f7 => Some(0x6046u16),
0x500f => Some(0x6047u16),
0x7317 => Some(0x6048u16),
0x730a => Some(0x6049u16),
0x731c => Some(0x604au16),
0x7316 => Some(0x604bu16),
0x731d => Some(0x604cu16),
0x7334 => Some(0x604du16),
0x732f => Some(0x604eu16),
0x7329 => Some(0x604fu16),
0x7325 => Some(0x6050u16),
0x733e => Some(0x6051u16),
0x734e => Some(0x6052u16),
0x734f => Some(0x6053u16),
0x9ed8 => Some(0x6054u16),
0x7357 => Some(0x6055u16),
0x736a => Some(0x6056u16),
0x7368 => Some(0x6057u16),
0x7370 => Some(0x6058u16),
0x7378 => Some(0x6059u16),
0x7375 => Some(0x605au16),
0x737b => Some(0x605bu16),
0x737a => Some(0x605cu16),
0x73c8 => Some(0x605du16),
0x73b3 => Some(0x605eu16),
0x73ce => Some(0x605fu16),
0x73bb => Some(0x6060u16),
0x73c0 => Some(0x6061u16),
0x73e5 => Some(0x6062u16),
0x73ee => Some(0x6063u16),
0x73de => Some(0x6064u16),
0x74a2 => Some(0x6065u16),
0x7405 => Some(0x6066u16),
0x746f => Some(0x6067u16),
0x7425 => Some(0x6068u16),
0x73f8 => Some(0x6069u16),
0x7432 => Some(0x606au16),
0x743a => Some(0x606bu16),
0x7455 => Some(0x606cu16),
0x743f => Some(0x606du16),
0x745f => Some(0x606eu16),
0x7459 => Some(0x606fu16),
0x7441 => Some(0x6070u16),
0x745c => Some(0x6071u16),
0x7469 => Some(0x6072u16),
0x7470 => Some(0x6073u16),
0x7463 => Some(0x6074u16),
0x746a => Some(0x6075u16),
0x7476 => Some(0x6076u16),
0x747e => Some(0x6077u16),
0x748b => Some(0x6078u16),
0x749e => Some(0x6079u16),
0x74a7 => Some(0x607au16),
0x74ca => Some(0x607bu16),
0x74cf => Some(0x607cu16),
0x74d4 => Some(0x607du16),
0x73f1 => Some(0x607eu16),
0x74e0 => Some(0x6121u16),
0x74e3 => Some(0x6122u16),
0x74e7 => Some(0x6123u16),
0x74e9 => Some(0x6124u16),
0x74ee => Some(0x6125u16),
0x74f2 => Some(0x6126u16),
0x74f0 => Some(0x6127u16),
0x74f1 => Some(0x6128u16),
0x74f8 => Some(0x6129u16),
0x74f7 => Some(0x612au16),
0x7504 => Some(0x612bu16),
0x7503 => Some(0x612cu16),
0x7505 => Some(0x612du16),
0x750c => Some(0x612eu16),
0x750e => Some(0x612fu16),
0x750d => Some(0x6130u16),
0x7515 => Some(0x6131u16),
0x7513 => Some(0x6132u16),
0x751e => Some(0x6133u16),
0x7526 => Some(0x6134u16),
0x752c => Some(0x6135u16),
0x753c => Some(0x6136u16),
0x7544 => Some(0x6137u16),
0x754d => Some(0x6138u16),
0x754a => Some(0x6139u16),
0x7549 => Some(0x613au16),
0x755b => Some(0x613bu16),
0x7546 => Some(0x613cu16),
0x755a => Some(0x613du16),
0x7569 => Some(0x613eu16),
0x7564 => Some(0x613fu16),
0x7567 => Some(0x6140u16),
0x756b => Some(0x6141u16),
0x756d => Some(0x6142u16),
0x7578 => Some(0x6143u16),
0x7576 => Some(0x6144u16),
0x7586 => Some(0x6145u16),
0x7587 => Some(0x6146u16),
0x7574 => Some(0x6147u16),
0x758a => Some(0x6148u16),
0x7589 => Some(0x6149u16),
0x7582 => Some(0x614au16),
0x7594 => Some(0x614bu16),
0x759a => Some(0x614cu16),
0x759d => Some(0x614du16),
0x75a5 => Some(0x614eu16),
0x75a3 => Some(0x614fu16),
0x75c2 => Some(0x6150u16),
0x75b3 => Some(0x6151u16),
0x75c3 => Some(0x6152u16),
0x75b5 => Some(0x6153u16),
0x75bd => Some(0x6154u16),
0x75b8 => Some(0x6155u16),
0x75bc => Some(0x6156u16),
0x75b1 => Some(0x6157u16),
0x75cd => Some(0x6158u16),
0x75ca => Some(0x6159u16),
0x75d2 => Some(0x615au16),
0x75d9 => Some(0x615bu16),
0x75e3 => Some(0x615cu16),
0x75de => Some(0x615du16),
0x75fe => Some(0x615eu16),
0x75ff => Some(0x615fu16),
0x75fc => Some(0x6160u16),
0x7601 => Some(0x6161u16),
0x75f0 => Some(0x6162u16),
0x75fa => Some(0x6163u16),
0x75f2 => Some(0x6164u16),
0x75f3 => Some(0x6165u16),
0x760b => Some(0x6166u16),
0x760d => Some(0x6167u16),
0x7609 => Some(0x6168u16),
0x761f => Some(0x6169u16),
0x7627 => Some(0x616au16),
0x7620 => Some(0x616bu16),
0x7621 => Some(0x616cu16),
0x7622 => Some(0x616du16),
0x7624 => Some(0x616eu16),
0x7634 => Some(0x616fu16),
0x7630 => Some(0x6170u16),
0x763b => Some(0x6171u16),
0x7647 => Some(0x6172u16),
0x7648 => Some(0x6173u16),
0x7646 => Some(0x6174u16),
0x765c => Some(0x6175u16),
0x7658 => Some(0x6176u16),
0x7661 => Some(0x6177u16),
0x7662 => Some(0x6178u16),
0x7668 => Some(0x6179u16),
0x7669 => Some(0x617au16),
0x766a => Some(0x617bu16),
0x7667 => Some(0x617cu16),
0x766c => Some(0x617du16),
0x7670 => Some(0x617eu16),
0x7672 => Some(0x6221u16),
0x7676 => Some(0x6222u16),
0x7678 => Some(0x6223u16),
0x767c => Some(0x6224u16),
0x7680 => Some(0x6225u16),
0x7683 => Some(0x6226u16),
0x7688 => Some(0x6227u16),
0x768b => Some(0x6228u16),
0x768e => Some(0x6229u16),
0x7696 => Some(0x622au16),
0x7693 => Some(0x622bu16),
0x7699 => Some(0x622cu16),
0x769a => Some(0x622du16),
0x76b0 => Some(0x622eu16),
0x76b4 => Some(0x622fu16),
0x76b8 => Some(0x6230u16),
0x76b9 => Some(0x6231u16),
0x76ba => Some(0x6232u16),
0x76c2 => Some(0x6233u16),
0x76cd => Some(0x6234u16),
0x76d6 => Some(0x6235u16),
0x76d2 => Some(0x6236u16),
0x76de => Some(0x6237u16),
0x76e1 => Some(0x6238u16),
0x76e5 => Some(0x6239u16),
0x76e7 => Some(0x623au16),
0x76ea => Some(0x623bu16),
0x862f => Some(0x623cu16),
0x76fb => Some(0x623du16),
0x7708 => Some(0x623eu16),
0x7707 => Some(0x623fu16),
0x7704 => Some(0x6240u16),
0x7729 => Some(0x6241u16),
0x7724 => Some(0x6242u16),
0x771e => Some(0x6243u16),
0x7725 => Some(0x6244u16),
0x7726 => Some(0x6245u16),
0x771b => Some(0x6246u16),
0x7737 => Some(0x6247u16),
0x7738 => Some(0x6248u16),
0x7747 => Some(0x6249u16),
0x775a => Some(0x624au16),
0x7768 => Some(0x624bu16),
0x776b => Some(0x624cu16),
0x775b => Some(0x624du16),
0x7765 => Some(0x624eu16),
0x777f => Some(0x624fu16),
0x777e => Some(0x6250u16),
0x7779 => Some(0x6251u16),
0x778e => Some(0x6252u16),
0x778b => Some(0x6253u16),
0x7791 => Some(0x6254u16),
0x77a0 => Some(0x6255u16),
0x779e => Some(0x6256u16),
0x77b0 => Some(0x6257u16),
0x77b6 => Some(0x6258u16),
0x77b9 => Some(0x6259u16),
0x77bf => Some(0x625au16),
0x77bc => Some(0x625bu16),
0x77bd => Some(0x625cu16),
0x77bb => Some(0x625du16),
0x77c7 => Some(0x625eu16),
0x77cd => Some(0x625fu16),
0x77d7 => Some(0x6260u16),
0x77da => Some(0x6261u16),
0x77dc => Some(0x6262u16),
0x77e3 => Some(0x6263u16),
0x77ee => Some(0x6264u16),
0x77fc => Some(0x6265u16),
0x780c => Some(0x6266u16),
0x7812 => Some(0x6267u16),
0x7926 => Some(0x6268u16),
0x7820 => Some(0x6269u16),
0x792a => Some(0x626au16),
0x7845 => Some(0x626bu16),
0x788e => Some(0x626cu16),
0x7874 => Some(0x626du16),
0x7886 => Some(0x626eu16),
0x787c => Some(0x626fu16),
0x789a => Some(0x6270u16),
0x788c => Some(0x6271u16),
0x78a3 => Some(0x6272u16),
0x78b5 => Some(0x6273u16),
0x78aa => Some(0x6274u16),
0x78af => Some(0x6275u16),
0x78d1 => Some(0x6276u16),
0x78c6 => Some(0x6277u16),
0x78cb => Some(0x6278u16),
0x78d4 => Some(0x6279u16),
0x78be => Some(0x627au16),
0x78bc => Some(0x627bu16),
0x78c5 => Some(0x627cu16),
0x78ca => Some(0x627du16),
0x78ec => Some(0x627eu16),
0x78e7 => Some(0x6321u16),
0x78da => Some(0x6322u16),
0x78fd => Some(0x6323u16),
0x78f4 => Some(0x6324u16),
0x7907 => Some(0x6325u16),
0x7912 => Some(0x6326u16),
0x7911 => Some(0x6327u16),
0x7919 => Some(0x6328u16),
0x792c => Some(0x6329u16),
0x792b => Some(0x632au16),
0x7940 => Some(0x632bu16),
0x7960 => Some(0x632cu16),
0x7957 => Some(0x632du16),
0x795f => Some(0x632eu16),
0x795a => Some(0x632fu16),
0x7955 => Some(0x6330u16),
0x7953 => Some(0x6331u16),
0x797a => Some(0x6332u16),
0x797f => Some(0x6333u16),
0x798a => Some(0x6334u16),
0x799d => Some(0x6335u16),
0x79a7 => Some(0x6336u16),
0x9f4b => Some(0x6337u16),
0x79aa => Some(0x6338u16),
0x79ae => Some(0x6339u16),
0x79b3 => Some(0x633au16),
0x79b9 => Some(0x633bu16),
0x79ba => Some(0x633cu16),
0x79c9 => Some(0x633du16),
0x79d5 => Some(0x633eu16),
0x79e7 => Some(0x633fu16),
0x79ec => Some(0x6340u16),
0x79e1 => Some(0x6341u16),
0x79e3 => Some(0x6342u16),
0x7a08 => Some(0x6343u16),
0x7a0d => Some(0x6344u16),
0x7a18 => Some(0x6345u16),
0x7a19 => Some(0x6346u16),
0x7a20 => Some(0x6347u16),
0x7a1f => Some(0x6348u16),
0x7980 => Some(0x6349u16),
0x7a31 => Some(0x634au16),
0x7a3b => Some(0x634bu16),
0x7a3e => Some(0x634cu16),
0x7a37 => Some(0x634du16),
0x7a43 => Some(0x634eu16),
0x7a57 => Some(0x634fu16),
0x7a49 => Some(0x6350u16),
0x7a61 => Some(0x6351u16),
0x7a62 => Some(0x6352u16),
0x7a69 => Some(0x6353u16),
0x9f9d => Some(0x6354u16),
0x7a70 => Some(0x6355u16),
0x7a79 => Some(0x6356u16),
0x7a7d => Some(0x6357u16),
0x7a88 => Some(0x6358u16),
0x7a97 => Some(0x6359u16),
0x7a95 => Some(0x635au16),
0x7a98 => Some(0x635bu16),
0x7a96 => Some(0x635cu16),
0x7aa9 => Some(0x635du16),
0x7ac8 => Some(0x635eu16),
0x7ab0 => Some(0x635fu16),
0x7ab6 => Some(0x6360u16),
0x7ac5 => Some(0x6361u16),
0x7ac4 => Some(0x6362u16),
0x7abf => Some(0x6363u16),
0x9083 => Some(0x6364u16),
0x7ac7 => Some(0x6365u16),
0x7aca => Some(0x6366u16),
0x7acd => Some(0x6367u16),
0x7acf => Some(0x6368u16),
0x7ad5 => Some(0x6369u16),
0x7ad3 => Some(0x636au16),
0x7ad9 => Some(0x636bu16),
0x7ada => Some(0x636cu16),
0x7add => Some(0x636du16),
0x7ae1 => Some(0x636eu16),
0x7ae2 => Some(0x636fu16),
0x7ae6 => Some(0x6370u16),
0x7aed => Some(0x6371u16),
0x7af0 => Some(0x6372u16),
0x7b02 => Some(0x6373u16),
0x7b0f => Some(0x6374u16),
0x7b0a => Some(0x6375u16),
0x7b06 => Some(0x6376u16),
0x7b33 => Some(0x6377u16),
0x7b18 => Some(0x6378u16),
0x7b19 => Some(0x6379u16),
0x7b1e => Some(0x637au16),
0x7b35 => Some(0x637bu16),
0x7b28 => Some(0x637cu16),
0x7b36 => Some(0x637du16),
0x7b50 => Some(0x637eu16),
0x7b7a => Some(0x6421u16),
0x7b04 => Some(0x6422u16),
0x7b4d => Some(0x6423u16),
0x7b0b => Some(0x6424u16),
0x7b4c => Some(0x6425u16),
0x7b45 => Some(0x6426u16),
0x7b75 => Some(0x6427u16),
0x7b65 => Some(0x6428u16),
0x7b74 => Some(0x6429u16),
0x7b67 => Some(0x642au16),
0x7b70 => Some(0x642bu16),
0x7b71 => Some(0x642cu16),
0x7b6c => Some(0x642du16),
0x7b6e => Some(0x642eu16),
0x7b9d => Some(0x642fu16),
0x7b98 => Some(0x6430u16),
0x7b9f => Some(0x6431u16),
0x7b8d => Some(0x6432u16),
0x7b9c => Some(0x6433u16),
0x7b9a => Some(0x6434u16),
0x7b8b => Some(0x6435u16),
0x7b92 => Some(0x6436u16),
0x7b8f => Some(0x6437u16),
0x7b5d => Some(0x6438u16),
0x7b99 => Some(0x6439u16),
0x7bcb => Some(0x643au16),
0x7bc1 => Some(0x643bu16),
0x7bcc => Some(0x643cu16),
0x7bcf => Some(0x643du16),
0x7bb4 => Some(0x643eu16),
0x7bc6 => Some(0x643fu16),
0x7bdd => Some(0x6440u16),
0x7be9 => Some(0x6441u16),
0x7c11 => Some(0x6442u16),
0x7c14 => Some(0x6443u16),
0x7be6 => Some(0x6444u16),
0x7be5 => Some(0x6445u16),
0x7c60 => Some(0x6446u16),
0x7c00 => Some(0x6447u16),
0x7c07 => Some(0x6448u16),
0x7c13 => Some(0x6449u16),
0x7bf3 => Some(0x644au16),
0x7bf7 => Some(0x644bu16),
0x7c17 => Some(0x644cu16),
0x7c0d => Some(0x644du16),
0x7bf6 => Some(0x644eu16),
0x7c23 => Some(0x644fu16),
0x7c27 => Some(0x6450u16),
0x7c2a => Some(0x6451u16),
0x7c1f => Some(0x6452u16),
0x7c37 => Some(0x6453u16),
0x7c2b => Some(0x6454u16),
0x7c3d => Some(0x6455u16),
0x7c4c => Some(0x6456u16),
0x7c43 => Some(0x6457u16),
0x7c54 => Some(0x6458u16),
0x7c4f => Some(0x6459u16),
0x7c40 => Some(0x645au16),
0x7c50 => Some(0x645bu16),
0x7c58 => Some(0x645cu16),
0x7c5f => Some(0x645du16),
0x7c64 => Some(0x645eu16),
0x7c56 => Some(0x645fu16),
0x7c65 => Some(0x6460u16),
0x7c6c => Some(0x6461u16),
0x7c75 => Some(0x6462u16),
0x7c83 => Some(0x6463u16),
0x7c90 => Some(0x6464u16),
0x7ca4 => Some(0x6465u16),
0x7cad => Some(0x6466u16),
0x7ca2 => Some(0x6467u16),
0x7cab => Some(0x6468u16),
0x7ca1 => Some(0x6469u16),
0x7ca8 => Some(0x646au16),
0x7cb3 => Some(0x646bu16),
0x7cb2 => Some(0x646cu16),
0x7cb1 => Some(0x646du16),
0x7cae => Some(0x646eu16),
0x7cb9 => Some(0x646fu16),
0x7cbd => Some(0x6470u16),
0x7cc0 => Some(0x6471u16),
0x7cc5 => Some(0x6472u16),
0x7cc2 => Some(0x6473u16),
0x7cd8 => Some(0x6474u16),
0x7cd2 => Some(0x6475u16),
0x7cdc => Some(0x6476u16),
0x7ce2 => Some(0x6477u16),
0x9b3b => Some(0x6478u16),
0x7cef => Some(0x6479u16),
0x7cf2 => Some(0x647au16),
0x7cf4 => Some(0x647bu16),
0x7cf6 => Some(0x647cu16),
0x7cfa => Some(0x647du16),
0x7d06 => Some(0x647eu16),
0x7d02 => Some(0x6521u16),
0x7d1c => Some(0x6522u16),
0x7d15 => Some(0x6523u16),
0x7d0a => Some(0x6524u16),
0x7d45 => Some(0x6525u16),
0x7d4b => Some(0x6526u16),
0x7d2e => Some(0x6527u16),
0x7d32 => Some(0x6528u16),
0x7d3f => Some(0x6529u16),
0x7d35 => Some(0x652au16),
0x7d46 => Some(0x652bu16),
0x7d73 => Some(0x652cu16),
0x7d56 => Some(0x652du16),
0x7d4e => Some(0x652eu16),
0x7d72 => Some(0x652fu16),
0x7d68 => Some(0x6530u16),
0x7d6e => Some(0x6531u16),
0x7d4f => Some(0x6532u16),
0x7d63 => Some(0x6533u16),
0x7d93 => Some(0x6534u16),
0x7d89 => Some(0x6535u16),
0x7d5b => Some(0x6536u16),
0x7d8f => Some(0x6537u16),
0x7d7d => Some(0x6538u16),
0x7d9b => Some(0x6539u16),
0x7dba => Some(0x653au16),
0x7dae => Some(0x653bu16),
0x7da3 => Some(0x653cu16),
0x7db5 => Some(0x653du16),
0x7dc7 => Some(0x653eu16),
0x7dbd => Some(0x653fu16),
0x7dab => Some(0x6540u16),
0x7e3d => Some(0x6541u16),
0x7da2 => Some(0x6542u16),
0x7daf => Some(0x6543u16),
0x7ddc => Some(0x6544u16),
0x7db8 => Some(0x6545u16),
0x7d9f => Some(0x6546u16),
0x7db0 => Some(0x6547u16),
0x7dd8 => Some(0x6548u16),
0x7ddd => Some(0x6549u16),
0x7de4 => Some(0x654au16),
0x7dde => Some(0x654bu16),
0x7dfb => Some(0x654cu16),
0x7df2 => Some(0x654du16),
0x7de1 => Some(0x654eu16),
0x7e05 => Some(0x654fu16),
0x7e0a => Some(0x6550u16),
0x7e23 => Some(0x6551u16),
0x7e21 => Some(0x6552u16),
0x7e12 => Some(0x6553u16),
0x7e31 => Some(0x6554u16),
0x7e1f => Some(0x6555u16),
0x7e09 => Some(0x6556u16),
0x7e0b => Some(0x6557u16),
0x7e22 => Some(0x6558u16),
0x7e46 => Some(0x6559u16),
0x7e66 => Some(0x655au16),
0x7e3b => Some(0x655bu16),
0x7e35 => Some(0x655cu16),
0x7e39 => Some(0x655du16),
0x7e43 => Some(0x655eu16),
0x7e37 => Some(0x655fu16),
0x7e32 => Some(0x6560u16),
0x7e3a => Some(0x6561u16),
0x7e67 => Some(0x6562u16),
0x7e5d => Some(0x6563u16),
0x7e56 => Some(0x6564u16),
0x7e5e => Some(0x6565u16),
0x7e59 => Some(0x6566u16),
0x7e5a => Some(0x6567u16),
0x7e79 => Some(0x6568u16),
0x7e6a => Some(0x6569u16),
0x7e69 => Some(0x656au16),
0x7e7c => Some(0x656bu16),
0x7e7b => Some(0x656cu16),
0x7e83 => Some(0x656du16),
0x7dd5 => Some(0x656eu16),
0x7e7d => Some(0x656fu16),
0x8fae => Some(0x6570u16),
0x7e7f => Some(0x6571u16),
0x7e88 => Some(0x6572u16),
0x7e89 => Some(0x6573u16),
0x7e8c => Some(0x6574u16),
0x7e92 => Some(0x6575u16),
0x7e90 => Some(0x6576u16),
0x7e93 => Some(0x6577u16),
0x7e94 => Some(0x6578u16),
0x7e96 => Some(0x6579u16),
0x7e8e => Some(0x657au16),
0x7e9b => Some(0x657bu16),
0x7e9c => Some(0x657cu16),
0x7f38 => Some(0x657du16),
0x7f3a => Some(0x657eu16),
0x7f45 => Some(0x6621u16),
0x7f4c => Some(0x6622u16),
0x7f4d => Some(0x6623u16),
0x7f4e => Some(0x6624u16),
0x7f50 => Some(0x6625u16),
0x7f51 => Some(0x6626u16),
0x7f55 => Some(0x6627u16),
0x7f54 => Some(0x6628u16),
0x7f58 => Some(0x6629u16),
0x7f5f => Some(0x662au16),
0x7f60 => Some(0x662bu16),
0x7f68 => Some(0x662cu16),
0x7f69 => Some(0x662du16),
0x7f67 => Some(0x662eu16),
0x7f78 => Some(0x662fu16),
0x7f82 => Some(0x6630u16),
0x7f86 => Some(0x6631u16),
0x7f83 => Some(0x6632u16),
0x7f88 => Some(0x6633u16),
0x7f87 => Some(0x6634u16),
0x7f8c => Some(0x6635u16),
0x7f94 => Some(0x6636u16),
0x7f9e => Some(0x6637u16),
0x7f9d => Some(0x6638u16),
0x7f9a => Some(0x6639u16),
0x7fa3 => Some(0x663au16),
0x7faf => Some(0x663bu16),
0x7fb2 => Some(0x663cu16),
0x7fb9 => Some(0x663du16),
0x7fae => Some(0x663eu16),
0x7fb6 => Some(0x663fu16),
0x7fb8 => Some(0x6640u16),
0x8b71 => Some(0x6641u16),
0x7fc5 => Some(0x6642u16),
0x7fc6 => Some(0x6643u16),
0x7fca => Some(0x6644u16),
0x7fd5 => Some(0x6645u16),
0x7fd4 => Some(0x6646u16),
0x7fe1 => Some(0x6647u16),
0x7fe6 => Some(0x6648u16),
0x7fe9 => Some(0x6649u16),
0x7ff3 => Some(0x664au16),
0x7ff9 => Some(0x664bu16),
0x98dc => Some(0x664cu16),
0x8006 => Some(0x664du16),
0x8004 => Some(0x664eu16),
0x800b => Some(0x664fu16),
0x8012 => Some(0x6650u16),
0x8018 => Some(0x6651u16),
0x8019 => Some(0x6652u16),
0x801c => Some(0x6653u16),
0x8021 => Some(0x6654u16),
0x8028 => Some(0x6655u16),
0x803f => Some(0x6656u16),
0x803b => Some(0x6657u16),
0x804a => Some(0x6658u16),
0x8046 => Some(0x6659u16),
0x8052 => Some(0x665au16),
0x8058 => Some(0x665bu16),
0x805a => Some(0x665cu16),
0x805f => Some(0x665du16),
0x8062 => Some(0x665eu16),
0x8068 => Some(0x665fu16),
0x8073 => Some(0x6660u16),
0x8072 => Some(0x6661u16),
0x8070 => Some(0x6662u16),
0x8076 => Some(0x6663u16),
0x8079 => Some(0x6664u16),
0x807d => Some(0x6665u16),
0x807f => Some(0x6666u16),
0x8084 => Some(0x6667u16),
0x8086 => Some(0x6668u16),
0x8085 => Some(0x6669u16),
0x809b => Some(0x666au16),
0x8093 => Some(0x666bu16),
0x809a => Some(0x666cu16),
0x80ad => Some(0x666du16),
0x5190 => Some(0x666eu16),
0x80ac => Some(0x666fu16),
0x80db => Some(0x6670u16),
0x80e5 => Some(0x6671u16),
0x80d9 => Some(0x6672u16),
0x80dd => Some(0x6673u16),
0x80c4 => Some(0x6674u16),
0x80da => Some(0x6675u16),
0x80d6 => Some(0x6676u16),
0x8109 => Some(0x6677u16),
0x80ef => Some(0x6678u16),
0x80f1 => Some(0x6679u16),
0x811b => Some(0x667au16),
0x8129 => Some(0x667bu16),
0x8123 => Some(0x667cu16),
0x812f => Some(0x667du16),
0x814b => Some(0x667eu16),
0x968b => Some(0x6721u16),
0x8146 => Some(0x6722u16),
0x813e => Some(0x6723u16),
0x8153 => Some(0x6724u16),
0x8151 => Some(0x6725u16),
0x80fc => Some(0x6726u16),
0x8171 => Some(0x6727u16),
0x816e => Some(0x6728u16),
0x8165 => Some(0x6729u16),
0x8166 => Some(0x672au16),
0x8174 => Some(0x672bu16),
0x8183 => Some(0x672cu16),
0x8188 => Some(0x672du16),
0x818a => Some(0x672eu16),
0x8180 => Some(0x672fu16),
0x8182 => Some(0x6730u16),
0x81a0 => Some(0x6731u16),
0x8195 => Some(0x6732u16),
0x81a4 => Some(0x6733u16),
0x81a3 => Some(0x6734u16),
0x815f => Some(0x6735u16),
0x8193 => Some(0x6736u16),
0x81a9 => Some(0x6737u16),
0x81b0 => Some(0x6738u16),
0x81b5 => Some(0x6739u16),
0x81be => Some(0x673au16),
0x81b8 => Some(0x673bu16),
0x81bd => Some(0x673cu16),
0x81c0 => Some(0x673du16),
0x81c2 => Some(0x673eu16),
0x81ba => Some(0x673fu16),
0x81c9 => Some(0x6740u16),
0x81cd => Some(0x6741u16),
0x81d1 => Some(0x6742u16),
0x81d9 => Some(0x6743u16),
0x81d8 => Some(0x6744u16),
0x81c8 => Some(0x6745u16),
0x81da => Some(0x6746u16),
0x81df => Some(0x6747u16),
0x81e0 => Some(0x6748u16),
0x81e7 => Some(0x6749u16),
0x81fa => Some(0x674au16),
0x81fb => Some(0x674bu16),
0x81fe => Some(0x674cu16),
0x8201 => Some(0x674du16),
0x8202 => Some(0x674eu16),
0x8205 => Some(0x674fu16),
0x8207 => Some(0x6750u16),
0x820a => Some(0x6751u16),
0x820d => Some(0x6752u16),
0x8210 => Some(0x6753u16),
0x8216 => Some(0x6754u16),
0x8229 => Some(0x6755u16),
0x822b => Some(0x6756u16),
0x8238 => Some(0x6757u16),
0x8233 => Some(0x6758u16),
0x8240 => Some(0x6759u16),
0x8259 => Some(0x675au16),
0x8258 => Some(0x675bu16),
0x825d => Some(0x675cu16),
0x825a => Some(0x675du16),
0x825f => Some(0x675eu16),
0x8264 => Some(0x675fu16),
0x8262 => Some(0x6760u16),
0x8268 => Some(0x6761u16),
0x826a => Some(0x6762u16),
0x826b => Some(0x6763u16),
0x822e => Some(0x6764u16),
0x8271 => Some(0x6765u16),
0x8277 => Some(0x6766u16),
0x8278 => Some(0x6767u16),
0x827e => Some(0x6768u16),
0x828d => Some(0x6769u16),
0x8292 => Some(0x676au16),
0x82ab => Some(0x676bu16),
0x829f => Some(0x676cu16),
0x82bb => Some(0x676du16),
0x82ac => Some(0x676eu16),
0x82e1 => Some(0x676fu16),
0x82e3 => Some(0x6770u16),
0x82df => Some(0x6771u16),
0x82d2 => Some(0x6772u16),
0x82f4 => Some(0x6773u16),
0x82f3 => Some(0x6774u16),
0x82fa => Some(0x6775u16),
0x8393 => Some(0x6776u16),
0x8303 => Some(0x6777u16),
0x82fb => Some(0x6778u16),
0x82f9 => Some(0x6779u16),
0x82de => Some(0x677au16),
0x8306 => Some(0x677bu16),
0x82dc => Some(0x677cu16),
0x8309 => Some(0x677du16),
0x82d9 => Some(0x677eu16),
0x8335 => Some(0x6821u16),
0x8334 => Some(0x6822u16),
0x8316 => Some(0x6823u16),
0x8332 => Some(0x6824u16),
0x8331 => Some(0x6825u16),
0x8340 => Some(0x6826u16),
0x8339 => Some(0x6827u16),
0x8350 => Some(0x6828u16),
0x8345 => Some(0x6829u16),
0x832f => Some(0x682au16),
0x832b => Some(0x682bu16),
0x8317 => Some(0x682cu16),
0x8318 => Some(0x682du16),
0x8385 => Some(0x682eu16),
0x839a => Some(0x682fu16),
0x83aa => Some(0x6830u16),
0x839f => Some(0x6831u16),
0x83a2 => Some(0x6832u16),
0x8396 => Some(0x6833u16),
0x8323 => Some(0x6834u16),
0x838e => Some(0x6835u16),
0x8387 => Some(0x6836u16),
0x838a => Some(0x6837u16),
0x837c => Some(0x6838u16),
0x83b5 => Some(0x6839u16),
0x8373 => Some(0x683au16),
0x8375 => Some(0x683bu16),
0x83a0 => Some(0x683cu16),
0x8389 => Some(0x683du16),
0x83a8 => Some(0x683eu16),
0x83f4 => Some(0x683fu16),
0x8413 => Some(0x6840u16),
0x83eb => Some(0x6841u16),
0x83ce => Some(0x6842u16),
0x83fd => Some(0x6843u16),
0x8403 => Some(0x6844u16),
0x83d8 => Some(0x6845u16),
0x840b => Some(0x6846u16),
0x83c1 => Some(0x6847u16),
0x83f7 => Some(0x6848u16),
0x8407 => Some(0x6849u16),
0x83e0 => Some(0x684au16),
0x83f2 => Some(0x684bu16),
0x840d => Some(0x684cu16),
0x8422 => Some(0x684du16),
0x8420 => Some(0x684eu16),
0x83bd => Some(0x684fu16),
0x8438 => Some(0x6850u16),
0x8506 => Some(0x6851u16),
0x83fb => Some(0x6852u16),
0x846d => Some(0x6853u16),
0x842a => Some(0x6854u16),
0x843c => Some(0x6855u16),
0x855a => Some(0x6856u16),
0x8484 => Some(0x6857u16),
0x8477 => Some(0x6858u16),
0x846b => Some(0x6859u16),
0x84ad => Some(0x685au16),
0x846e => Some(0x685bu16),
0x8482 => Some(0x685cu16),
0x8469 => Some(0x685du16),
0x8446 => Some(0x685eu16),
0x842c => Some(0x685fu16),
0x846f => Some(0x6860u16),
0x8479 => Some(0x6861u16),
0x8435 => Some(0x6862u16),
0x84ca => Some(0x6863u16),
0x8462 => Some(0x6864u16),
0x84b9 => Some(0x6865u16),
0x84bf => Some(0x6866u16),
0x849f => Some(0x6867u16),
0x84d9 => Some(0x6868u16),
0x84cd => Some(0x6869u16),
0x84bb => Some(0x686au16),
0x84da => Some(0x686bu16),
0x84d0 => Some(0x686cu16),
0x84c1 => Some(0x686du16),
0x84c6 => Some(0x686eu16),
0x84d6 => Some(0x686fu16),
0x84a1 => Some(0x6870u16),
0x8521 => Some(0x6871u16),
0x84ff => Some(0x6872u16),
0x84f4 => Some(0x6873u16),
0x8517 => Some(0x6874u16),
0x8518 => Some(0x6875u16),
0x852c => Some(0x6876u16),
0x851f => Some(0x6877u16),
0x8515 => Some(0x6878u16),
0x8514 => Some(0x6879u16),
0x84fc => Some(0x687au16),
0x8540 => Some(0x687bu16),
0x8563 => Some(0x687cu16),
0x8558 => Some(0x687du16),
0x8548 => Some(0x687eu16),
0x8541 => Some(0x6921u16),
0x8602 => Some(0x6922u16),
0x854b => Some(0x6923u16),
0x8555 => Some(0x6924u16),
0x8580 => Some(0x6925u16),
0x85a4 => Some(0x6926u16),
0x8588 => Some(0x6927u16),
0x8591 => Some(0x6928u16),
0x858a => Some(0x6929u16),
0x85a8 => Some(0x692au16),
0x856d => Some(0x692bu16),
0x8594 => Some(0x692cu16),
0x859b => Some(0x692du16),
0x85ea => Some(0x692eu16),
0x8587 => Some(0x692fu16),
0x859c => Some(0x6930u16),
0x8577 => Some(0x6931u16),
0x857e => Some(0x6932u16),
0x8590 => Some(0x6933u16),
0x85c9 => Some(0x6934u16),
0x85ba => Some(0x6935u16),
0x85cf => Some(0x6936u16),
0x85b9 => Some(0x6937u16),
0x85d0 => Some(0x6938u16),
0x85d5 => Some(0x6939u16),
0x85dd => Some(0x693au16),
0x85e5 => Some(0x693bu16),
0x85dc => Some(0x693cu16),
0x85f9 => Some(0x693du16),
0x860a => Some(0x693eu16),
0x8613 => Some(0x693fu16),
0x860b => Some(0x6940u16),
0x85fe => Some(0x6941u16),
0x85fa => Some(0x6942u16),
0x8606 => Some(0x6943u16),
0x8622 => Some(0x6944u16),
0x861a => Some(0x6945u16),
0x8630 => Some(0x6946u16),
0x863f => Some(0x6947u16),
0x864d => Some(0x6948u16),
0x4e55 => Some(0x6949u16),
0x8654 => Some(0x694au16),
0x865f => Some(0x694bu16),
0x8667 => Some(0x694cu16),
0x8671 => Some(0x694du16),
0x8693 => Some(0x694eu16),
0x86a3 => Some(0x694fu16),
0x86a9 => Some(0x6950u16),
0x86aa => Some(0x6951u16),
0x868b => Some(0x6952u16),
0x868c => Some(0x6953u16),
0x86b6 => Some(0x6954u16),
0x86af => Some(0x6955u16),
0x86c4 => Some(0x6956u16),
0x86c6 => Some(0x6957u16),
0x86b0 => Some(0x6958u16),
0x86c9 => Some(0x6959u16),
0x8823 => Some(0x695au16),
0x86ab => Some(0x695bu16),
0x86d4 => Some(0x695cu16),
0x86de => Some(0x695du16),
0x86e9 => Some(0x695eu16),
0x86ec => Some(0x695fu16),
0x86df => Some(0x6960u16),
0x86db => Some(0x6961u16),
0x86ef => Some(0x6962u16),
0x8712 => Some(0x6963u16),
0x8706 => Some(0x6964u16),
0x8708 => Some(0x6965u16),
0x8700 => Some(0x6966u16),
0x8703 => Some(0x6967u16),
0x86fb => Some(0x6968u16),
0x8711 => Some(0x6969u16),
0x8709 => Some(0x696au16),
0x870d => Some(0x696bu16),
0x86f9 => Some(0x696cu16),
0x870a => Some(0x696du16),
0x8734 => Some(0x696eu16),
0x873f => Some(0x696fu16),
0x8737 => Some(0x6970u16),
0x873b => Some(0x6971u16),
0x8725 => Some(0x6972u16),
0x8729 => Some(0x6973u16),
0x871a => Some(0x6974u16),
0x8760 => Some(0x6975u16),
0x875f => Some(0x6976u16),
0x8778 => Some(0x6977u16),
0x874c => Some(0x6978u16),
0x874e => Some(0x6979u16),
0x8774 => Some(0x697au16),
0x8757 => Some(0x697bu16),
0x8768 => Some(0x697cu16),
0x876e => Some(0x697du16),
0x8759 => Some(0x697eu16),
0x8753 => Some(0x6a21u16),
0x8763 => Some(0x6a22u16),
0x876a => Some(0x6a23u16),
0x8805 => Some(0x6a24u16),
0x87a2 => Some(0x6a25u16),
0x879f => Some(0x6a26u16),
0x8782 => Some(0x6a27u16),
0x87af => Some(0x6a28u16),
0x87cb => Some(0x6a29u16),
0x87bd => Some(0x6a2au16),
0x87c0 => Some(0x6a2bu16),
0x87d0 => Some(0x6a2cu16),
0x96d6 => Some(0x6a2du16),
0x87ab => Some(0x6a2eu16),
0x87c4 => Some(0x6a2fu16),
0x87b3 => Some(0x6a30u16),
0x87c7 => Some(0x6a31u16),
0x87c6 => Some(0x6a32u16),
0x87bb => Some(0x6a33u16),
0x87ef => Some(0x6a34u16),
0x87f2 => Some(0x6a35u16),
0x87e0 => Some(0x6a36u16),
0x880f => Some(0x6a37u16),
0x880d => Some(0x6a38u16),
0x87fe => Some(0x6a39u16),
0x87f6 => Some(0x6a3au16),
0x87f7 => Some(0x6a3bu16),
0x880e => Some(0x6a3cu16),
0x87d2 => Some(0x6a3du16),
0x8811 => Some(0x6a3eu16),
0x8816 => Some(0x6a3fu16),
0x8815 => Some(0x6a40u16),
0x8822 => Some(0x6a41u16),
0x8821 => Some(0x6a42u16),
0x8831 => Some(0x6a43u16),
0x8836 => Some(0x6a44u16),
0x8839 => Some(0x6a45u16),
0x8827 => Some(0x6a46u16),
0x883b => Some(0x6a47u16),
0x8844 => Some(0x6a48u16),
0x8842 => Some(0x6a49u16),
0x8852 => Some(0x6a4au16),
0x8859 => Some(0x6a4bu16),
0x885e => Some(0x6a4cu16),
0x8862 => Some(0x6a4du16),
0x886b => Some(0x6a4eu16),
0x8881 => Some(0x6a4fu16),
0x887e => Some(0x6a50u16),
0x889e => Some(0x6a51u16),
0x8875 => Some(0x6a52u16),
0x887d => Some(0x6a53u16),
0x88b5 => Some(0x6a54u16),
0x8872 => Some(0x6a55u16),
0x8882 => Some(0x6a56u16),
0x8897 => Some(0x6a57u16),
0x8892 => Some(0x6a58u16),
0x88ae => Some(0x6a59u16),
0x8899 => Some(0x6a5au16),
0x88a2 => Some(0x6a5bu16),
0x888d => Some(0x6a5cu16),
0x88a4 => Some(0x6a5du16),
0x88b0 => Some(0x6a5eu16),
0x88bf => Some(0x6a5fu16),
0x88b1 => Some(0x6a60u16),
0x88c3 => Some(0x6a61u16),
0x88c4 => Some(0x6a62u16),
0x88d4 => Some(0x6a63u16),
0x88d8 => Some(0x6a64u16),
0x88d9 => Some(0x6a65u16),
0x88dd => Some(0x6a66u16),
0x88f9 => Some(0x6a67u16),
0x8902 => Some(0x6a68u16),
0x88fc => Some(0x6a69u16),
0x88f4 => Some(0x6a6au16),
0x88e8 => Some(0x6a6bu16),
0x88f2 => Some(0x6a6cu16),
0x8904 => Some(0x6a6du16),
0x890c => Some(0x6a6eu16),
0x890a => Some(0x6a6fu16),
0x8913 => Some(0x6a70u16),
0x8943 => Some(0x6a71u16),
0x891e => Some(0x6a72u16),
0x8925 => Some(0x6a73u16),
0x892a => Some(0x6a74u16),
0x892b => Some(0x6a75u16),
0x8941 => Some(0x6a76u16),
0x8944 => Some(0x6a77u16),
0x893b => Some(0x6a78u16),
0x8936 => Some(0x6a79u16),
0x8938 => Some(0x6a7au16),
0x894c => Some(0x6a7bu16),
0x891d => Some(0x6a7cu16),
0x8960 => Some(0x6a7du16),
0x895e => Some(0x6a7eu16),
0x8966 => Some(0x6b21u16),
0x8964 => Some(0x6b22u16),
0x896d => Some(0x6b23u16),
0x896a => Some(0x6b24u16),
0x896f => Some(0x6b25u16),
0x8974 => Some(0x6b26u16),
0x8977 => Some(0x6b27u16),
0x897e => Some(0x6b28u16),
0x8983 => Some(0x6b29u16),
0x8988 => Some(0x6b2au16),
0x898a => Some(0x6b2bu16),
0x8993 => Some(0x6b2cu16),
0x8998 => Some(0x6b2du16),
0x89a1 => Some(0x6b2eu16),
0x89a9 => Some(0x6b2fu16),
0x89a6 => Some(0x6b30u16),
0x89ac => Some(0x6b31u16),
0x89af => Some(0x6b32u16),
0x89b2 => Some(0x6b33u16),
0x89ba => Some(0x6b34u16),
0x89bd => Some(0x6b35u16),
0x89bf => Some(0x6b36u16),
0x89c0 => Some(0x6b37u16),
0x89da => Some(0x6b38u16),
0x89dc => Some(0x6b39u16),
0x89dd => Some(0x6b3au16),
0x89e7 => Some(0x6b3bu16),
0x89f4 => Some(0x6b3cu16),
0x89f8 => Some(0x6b3du16),
0x8a03 => Some(0x6b3eu16),
0x8a16 => Some(0x6b3fu16),
0x8a10 => Some(0x6b40u16),
0x8a0c => Some(0x6b41u16),
0x8a1b => Some(0x6b42u16),
0x8a1d => Some(0x6b43u16),
0x8a25 => Some(0x6b44u16),
0x8a36 => Some(0x6b45u16),
0x8a41 => Some(0x6b46u16),
0x8a5b => Some(0x6b47u16),
0x8a52 => Some(0x6b48u16),
0x8a46 => Some(0x6b49u16),
0x8a48 => Some(0x6b4au16),
0x8a7c => Some(0x6b4bu16),
0x8a6d => Some(0x6b4cu16),
0x8a6c => Some(0x6b4du16),
0x8a62 => Some(0x6b4eu16),
0x8a85 => Some(0x6b4fu16),
0x8a82 => Some(0x6b50u16),
0x8a84 => Some(0x6b51u16),
0x8aa8 => Some(0x6b52u16),
0x8aa1 => Some(0x6b53u16),
0x8a91 => Some(0x6b54u16),
0x8aa5 => Some(0x6b55u16),
0x8aa6 => Some(0x6b56u16),
0x8a9a => Some(0x6b57u16),
0x8aa3 => Some(0x6b58u16),
0x8ac4 => Some(0x6b59u16),
0x8acd => Some(0x6b5au16),
0x8ac2 => Some(0x6b5bu16),
0x8ada => Some(0x6b5cu16),
0x8aeb => Some(0x6b5du16),
0x8af3 => Some(0x6b5eu16),
0x8ae7 => Some(0x6b5fu16),
0x8ae4 => Some(0x6b60u16),
0x8af1 => Some(0x6b61u16),
0x8b14 => Some(0x6b62u16),
0x8ae0 => Some(0x6b63u16),
0x8ae2 => Some(0x6b64u16),
0x8af7 => Some(0x6b65u16),
0x8ade => Some(0x6b66u16),
0x8adb => Some(0x6b67u16),
0x8b0c => Some(0x6b68u16),
0x8b07 => Some(0x6b69u16),
0x8b1a => Some(0x6b6au16),
0x8ae1 => Some(0x6b6bu16),
0x8b16 => Some(0x6b6cu16),
0x8b10 => Some(0x6b6du16),
0x8b17 => Some(0x6b6eu16),
0x8b20 => Some(0x6b6fu16),
0x8b33 => Some(0x6b70u16),
0x97ab => Some(0x6b71u16),
0x8b26 => Some(0x6b72u16),
0x8b2b => Some(0x6b73u16),
0x8b3e => Some(0x6b74u16),
0x8b28 => Some(0x6b75u16),
0x8b41 => Some(0x6b76u16),
0x8b4c => Some(0x6b77u16),
0x8b4f => Some(0x6b78u16),
0x8b4e => Some(0x6b79u16),
0x8b49 => Some(0x6b7au16),
0x8b56 => Some(0x6b7bu16),
0x8b5b => Some(0x6b7cu16),
0x8b5a => Some(0x6b7du16),
0x8b6b => Some(0x6b7eu16),
0x8b5f => Some(0x6c21u16),
0x8b6c => Some(0x6c22u16),
0x8b6f => Some(0x6c23u16),
0x8b74 => Some(0x6c24u16),
0x8b7d => Some(0x6c25u16),
0x8b80 => Some(0x6c26u16),
0x8b8c => Some(0x6c27u16),
0x8b8e => Some(0x6c28u16),
0x8b92 => Some(0x6c29u16),
0x8b93 => Some(0x6c2au16),
0x8b96 => Some(0x6c2bu16),
0x8b99 => Some(0x6c2cu16),
0x8b9a => Some(0x6c2du16),
0x8c3a => Some(0x6c2eu16),
0x8c41 => Some(0x6c2fu16),
0x8c3f => Some(0x6c30u16),
0x8c48 => Some(0x6c31u16),
0x8c4c => Some(0x6c32u16),
0x8c4e => Some(0x6c33u16),
0x8c50 => Some(0x6c34u16),
0x8c55 => Some(0x6c35u16),
0x8c62 => Some(0x6c36u16),
0x8c6c => Some(0x6c37u16),
0x8c78 => Some(0x6c38u16),
0x8c7a => Some(0x6c39u16),
0x8c82 => Some(0x6c3au16),
0x8c89 => Some(0x6c3bu16),
0x8c85 => Some(0x6c3cu16),
0x8c8a => Some(0x6c3du16),
0x8c8d => Some(0x6c3eu16),
0x8c8e => Some(0x6c3fu16),
0x8c94 => Some(0x6c40u16),
0x8c7c => Some(0x6c41u16),
0x8c98 => Some(0x6c42u16),
0x621d => Some(0x6c43u16),
0x8cad => Some(0x6c44u16),
0x8caa => Some(0x6c45u16),
0x8cbd => Some(0x6c46u16),
0x8cb2 => Some(0x6c47u16),
0x8cb3 => Some(0x6c48u16),
0x8cae => Some(0x6c49u16),
0x8cb6 => Some(0x6c4au16),
0x8cc8 => Some(0x6c4bu16),
0x8cc1 => Some(0x6c4cu16),
0x8ce4 => Some(0x6c4du16),
0x8ce3 => Some(0x6c4eu16),
0x8cda => Some(0x6c4fu16),
0x8cfd => Some(0x6c50u16),
0x8cfa => Some(0x6c51u16),
0x8cfb => Some(0x6c52u16),
0x8d04 => Some(0x6c53u16),
0x8d05 => Some(0x6c54u16),
0x8d0a => Some(0x6c55u16),
0x8d07 => Some(0x6c56u16),
0x8d0f => Some(0x6c57u16),
0x8d0d => Some(0x6c58u16),
0x8d10 => Some(0x6c59u16),
0x9f4e => Some(0x6c5au16),
0x8d13 => Some(0x6c5bu16),
0x8ccd => Some(0x6c5cu16),
0x8d14 => Some(0x6c5du16),
0x8d16 => Some(0x6c5eu16),
0x8d67 => Some(0x6c5fu16),
0x8d6d => Some(0x6c60u16),
0x8d71 => Some(0x6c61u16),
0x8d73 => Some(0x6c62u16),
0x8d81 => Some(0x6c63u16),
0x8d99 => Some(0x6c64u16),
0x8dc2 => Some(0x6c65u16),
0x8dbe => Some(0x6c66u16),
0x8dba => Some(0x6c67u16),
0x8dcf => Some(0x6c68u16),
0x8dda => Some(0x6c69u16),
0x8dd6 => Some(0x6c6au16),
0x8dcc => Some(0x6c6bu16),
0x8ddb => Some(0x6c6cu16),
0x8dcb => Some(0x6c6du16),
0x8dea => Some(0x6c6eu16),
0x8deb => Some(0x6c6fu16),
0x8ddf => Some(0x6c70u16),
0x8de3 => Some(0x6c71u16),
0x8dfc => Some(0x6c72u16),
0x8e08 => Some(0x6c73u16),
0x8e09 => Some(0x6c74u16),
0x8dff => Some(0x6c75u16),
0x8e1d => Some(0x6c76u16),
0x8e1e => Some(0x6c77u16),
0x8e10 => Some(0x6c78u16),
0x8e1f => Some(0x6c79u16),
0x8e42 => Some(0x6c7au16),
0x8e35 => Some(0x6c7bu16),
0x8e30 => Some(0x6c7cu16),
0x8e34 => Some(0x6c7du16),
0x8e4a => Some(0x6c7eu16),
0x8e47 => Some(0x6d21u16),
0x8e49 => Some(0x6d22u16),
0x8e4c => Some(0x6d23u16),
0x8e50 => Some(0x6d24u16),
0x8e48 => Some(0x6d25u16),
0x8e59 => Some(0x6d26u16),
0x8e64 => Some(0x6d27u16),
0x8e60 => Some(0x6d28u16),
0x8e2a => Some(0x6d29u16),
0x8e63 => Some(0x6d2au16),
0x8e55 => Some(0x6d2bu16),
0x8e76 => Some(0x6d2cu16),
0x8e72 => Some(0x6d2du16),
0x8e7c => Some(0x6d2eu16),
0x8e81 => Some(0x6d2fu16),
0x8e87 => Some(0x6d30u16),
0x8e85 => Some(0x6d31u16),
0x8e84 => Some(0x6d32u16),
0x8e8b => Some(0x6d33u16),
0x8e8a => Some(0x6d34u16),
0x8e93 => Some(0x6d35u16),
0x8e91 => Some(0x6d36u16),
0x8e94 => Some(0x6d37u16),
0x8e99 => Some(0x6d38u16),
0x8eaa => Some(0x6d39u16),
0x8ea1 => Some(0x6d3au16),
0x8eac => Some(0x6d3bu16),
0x8eb0 => Some(0x6d3cu16),
0x8ec6 => Some(0x6d3du16),
0x8eb1 => Some(0x6d3eu16),
0x8ebe => Some(0x6d3fu16),
0x8ec5 => Some(0x6d40u16),
0x8ec8 => Some(0x6d41u16),
0x8ecb => Some(0x6d42u16),
0x8edb => Some(0x6d43u16),
0x8ee3 => Some(0x6d44u16),
0x8efc => Some(0x6d45u16),
0x8efb => Some(0x6d46u16),
0x8eeb => Some(0x6d47u16),
0x8efe => Some(0x6d48u16),
0x8f0a => Some(0x6d49u16),
0x8f05 => Some(0x6d4au16),
0x8f15 => Some(0x6d4bu16),
0x8f12 => Some(0x6d4cu16),
0x8f19 => Some(0x6d4du16),
0x8f13 => Some(0x6d4eu16),
0x8f1c => Some(0x6d4fu16),
0x8f1f => Some(0x6d50u16),
0x8f1b => Some(0x6d51u16),
0x8f0c => Some(0x6d52u16),
0x8f26 => Some(0x6d53u16),
0x8f33 => Some(0x6d54u16),
0x8f3b => Some(0x6d55u16),
0x8f39 => Some(0x6d56u16),
0x8f45 => Some(0x6d57u16),
0x8f42 => Some(0x6d58u16),
0x8f3e => Some(0x6d59u16),
0x8f4c => Some(0x6d5au16),
0x8f49 => Some(0x6d5bu16),
0x8f46 => Some(0x6d5cu16),
0x8f4e => Some(0x6d5du16),
0x8f57 => Some(0x6d5eu16),
0x8f5c => Some(0x6d5fu16),
0x8f62 => Some(0x6d60u16),
0x8f63 => Some(0x6d61u16),
0x8f64 => Some(0x6d62u16),
0x8f9c => Some(0x6d63u16),
0x8f9f => Some(0x6d64u16),
0x8fa3 => Some(0x6d65u16),
0x8fad => Some(0x6d66u16),
0x8faf => Some(0x6d67u16),
0x8fb7 => Some(0x6d68u16),
0x8fda => Some(0x6d69u16),
0x8fe5 => Some(0x6d6au16),
0x8fe2 => Some(0x6d6bu16),
0x8fea => Some(0x6d6cu16),
0x8fef => Some(0x6d6du16),
0x9087 => Some(0x6d6eu16),
0x8ff4 => Some(0x6d6fu16),
0x9005 => Some(0x6d70u16),
0x8ff9 => Some(0x6d71u16),
0x8ffa => Some(0x6d72u16),
0x9011 => Some(0x6d73u16),
0x9015 => Some(0x6d74u16),
0x9021 => Some(0x6d75u16),
0x900d => Some(0x6d76u16),
0x901e => Some(0x6d77u16),
0x9016 => Some(0x6d78u16),
0x900b => Some(0x6d79u16),
0x9027 => Some(0x6d7au16),
0x9036 => Some(0x6d7bu16),
0x9035 => Some(0x6d7cu16),
0x9039 => Some(0x6d7du16),
0x8ff8 => Some(0x6d7eu16),
0x904f => Some(0x6e21u16),
0x9050 => Some(0x6e22u16),
0x9051 => Some(0x6e23u16),
0x9052 => Some(0x6e24u16),
0x900e => Some(0x6e25u16),
0x9049 => Some(0x6e26u16),
0x903e => Some(0x6e27u16),
0x9056 => Some(0x6e28u16),
0x9058 => Some(0x6e29u16),
0x905e => Some(0x6e2au16),
0x9068 => Some(0x6e2bu16),
0x906f => Some(0x6e2cu16),
0x9076 => Some(0x6e2du16),
0x96a8 => Some(0x6e2eu16),
0x9072 => Some(0x6e2fu16),
0x9082 => Some(0x6e30u16),
0x907d => Some(0x6e31u16),
0x9081 => Some(0x6e32u16),
0x9080 => Some(0x6e33u16),
0x908a => Some(0x6e34u16),
0x9089 => Some(0x6e35u16),
0x908f => Some(0x6e36u16),
0x90a8 => Some(0x6e37u16),
0x90af => Some(0x6e38u16),
0x90b1 => Some(0x6e39u16),
0x90b5 => Some(0x6e3au16),
0x90e2 => Some(0x6e3bu16),
0x90e4 => Some(0x6e3cu16),
0x6248 => Some(0x6e3du16),
0x90db => Some(0x6e3eu16),
0x9102 => Some(0x6e3fu16),
0x9112 => Some(0x6e40u16),
0x9119 => Some(0x6e41u16),
0x9132 => Some(0x6e42u16),
0x9130 => Some(0x6e43u16),
0x914a => Some(0x6e44u16),
0x9156 => Some(0x6e45u16),
0x9158 => Some(0x6e46u16),
0x9163 => Some(0x6e47u16),
0x9165 => Some(0x6e48u16),
0x9169 => Some(0x6e49u16),
0x9173 => Some(0x6e4au16),
0x9172 => Some(0x6e4bu16),
0x918b => Some(0x6e4cu16),
0x9189 => Some(0x6e4du16),
0x9182 => Some(0x6e4eu16),
0x91a2 => Some(0x6e4fu16),
0x91ab => Some(0x6e50u16),
0x91af => Some(0x6e51u16),
0x91aa => Some(0x6e52u16),
0x91b5 => Some(0x6e53u16),
0x91b4 => Some(0x6e54u16),
0x91ba => Some(0x6e55u16),
0x91c0 => Some(0x6e56u16),
0x91c1 => Some(0x6e57u16),
0x91c9 => Some(0x6e58u16),
0x91cb => Some(0x6e59u16),
0x91d0 => Some(0x6e5au16),
0x91d6 => Some(0x6e5bu16),
0x91df => Some(0x6e5cu16),
0x91e1 => Some(0x6e5du16),
0x91db => Some(0x6e5eu16),
0x91fc => Some(0x6e5fu16),
0x91f5 => Some(0x6e60u16),
0x91f6 => Some(0x6e61u16),
0x921e => Some(0x6e62u16),
0x91ff => Some(0x6e63u16),
0x9214 => Some(0x6e64u16),
0x922c => Some(0x6e65u16),
0x9215 => Some(0x6e66u16),
0x9211 => Some(0x6e67u16),
0x925e => Some(0x6e68u16),
0x9257 => Some(0x6e69u16),
0x9245 => Some(0x6e6au16),
0x9249 => Some(0x6e6bu16),
0x9264 => Some(0x6e6cu16),
0x9248 => Some(0x6e6du16),
0x9295 => Some(0x6e6eu16),
0x923f => Some(0x6e6fu16),
0x924b => Some(0x6e70u16),
0x9250 => Some(0x6e71u16),
0x929c => Some(0x6e72u16),
0x9296 => Some(0x6e73u16),
0x9293 => Some(0x6e74u16),
0x929b => Some(0x6e75u16),
0x925a => Some(0x6e76u16),
0x92cf => Some(0x6e77u16),
0x92b9 => Some(0x6e78u16),
0x92b7 => Some(0x6e79u16),
0x92e9 => Some(0x6e7au16),
0x930f => Some(0x6e7bu16),
0x92fa => Some(0x6e7cu16),
0x9344 => Some(0x6e7du16),
0x932e => Some(0x6e7eu16),
0x9319 => Some(0x6f21u16),
0x9322 => Some(0x6f22u16),
0x931a => Some(0x6f23u16),
0x9323 => Some(0x6f24u16),
0x933a => Some(0x6f25u16),
0x9335 => Some(0x6f26u16),
0x933b => Some(0x6f27u16),
0x935c => Some(0x6f28u16),
0x9360 => Some(0x6f29u16),
0x937c => Some(0x6f2au16),
0x936e => Some(0x6f2bu16),
0x9356 => Some(0x6f2cu16),
0x93b0 => Some(0x6f2du16),
0x93ac => Some(0x6f2eu16),
0x93ad => Some(0x6f2fu16),
0x9394 => Some(0x6f30u16),
0x93b9 => Some(0x6f31u16),
0x93d6 => Some(0x6f32u16),
0x93d7 => Some(0x6f33u16),
0x93e8 => Some(0x6f34u16),
0x93e5 => Some(0x6f35u16),
0x93d8 => Some(0x6f36u16),
0x93c3 => Some(0x6f37u16),
0x93dd => Some(0x6f38u16),
0x93d0 => Some(0x6f39u16),
0x93c8 => Some(0x6f3au16),
0x93e4 => Some(0x6f3bu16),
0x941a => Some(0x6f3cu16),
0x9414 => Some(0x6f3du16),
0x9413 => Some(0x6f3eu16),
0x9403 => Some(0x6f3fu16),
0x9407 => Some(0x6f40u16),
0x9410 => Some(0x6f41u16),
0x9436 => Some(0x6f42u16),
0x942b => Some(0x6f43u16),
0x9435 => Some(0x6f44u16),
0x9421 => Some(0x6f45u16),
0x943a => Some(0x6f46u16),
0x9441 => Some(0x6f47u16),
0x9452 => Some(0x6f48u16),
0x9444 => Some(0x6f49u16),
0x945b => Some(0x6f4au16),
0x9460 => Some(0x6f4bu16),
0x9462 => Some(0x6f4cu16),
0x945e => Some(0x6f4du16),
0x946a => Some(0x6f4eu16),
0x9229 => Some(0x6f4fu16),
0x9470 => Some(0x6f50u16),
0x9475 => Some(0x6f51u16),
0x9477 => Some(0x6f52u16),
0x947d => Some(0x6f53u16),
0x945a => Some(0x6f54u16),
0x947c => Some(0x6f55u16),
0x947e => Some(0x6f56u16),
0x9481 => Some(0x6f57u16),
0x947f => Some(0x6f58u16),
0x9582 => Some(0x6f59u16),
0x9587 => Some(0x6f5au16),
0x958a => Some(0x6f5bu16),
0x9594 => Some(0x6f5cu16),
0x9596 => Some(0x6f5du16),
0x9598 => Some(0x6f5eu16),
0x9599 => Some(0x6f5fu16),
0x95a0 => Some(0x6f60u16),
0x95a8 => Some(0x6f61u16),
0x95a7 => Some(0x6f62u16),
0x95ad => Some(0x6f63u16),
0x95bc => Some(0x6f64u16),
0x95bb => Some(0x6f65u16),
0x95b9 => Some(0x6f66u16),
0x95be => Some(0x6f67u16),
0x95ca => Some(0x6f68u16),
0x6ff6 => Some(0x6f69u16),
0x95c3 => Some(0x6f6au16),
0x95cd => Some(0x6f6bu16),
0x95cc => Some(0x6f6cu16),
0x95d5 => Some(0x6f6du16),
0x95d4 => Some(0x6f6eu16),
0x95d6 => Some(0x6f6fu16),
0x95dc => Some(0x6f70u16),
0x95e1 => Some(0x6f71u16),
0x95e5 => Some(0x6f72u16),
0x95e2 => Some(0x6f73u16),
0x9621 => Some(0x6f74u16),
0x9628 => Some(0x6f75u16),
0x962e => Some(0x6f76u16),
0x962f => Some(0x6f77u16),
0x9642 => Some(0x6f78u16),
0x964c => Some(0x6f79u16),
0x964f => Some(0x6f7au16),
0x964b => Some(0x6f7bu16),
0x9677 => Some(0x6f7cu16),
0x965c => Some(0x6f7du16),
0x965e => Some(0x6f7eu16),
0x965d => Some(0x7021u16),
0x965f => Some(0x7022u16),
0x9666 => Some(0x7023u16),
0x9672 => Some(0x7024u16),
0x966c => Some(0x7025u16),
0x968d => Some(0x7026u16),
0x9698 => Some(0x7027u16),
0x9695 => Some(0x7028u16),
0x9697 => Some(0x7029u16),
0x96aa => Some(0x702au16),
0x96a7 => Some(0x702bu16),
0x96b1 => Some(0x702cu16),
0x96b2 => Some(0x702du16),
0x96b0 => Some(0x702eu16),
0x96b4 => Some(0x702fu16),
0x96b6 => Some(0x7030u16),
0x96b8 => Some(0x7031u16),
0x96b9 => Some(0x7032u16),
0x96ce => Some(0x7033u16),
0x96cb => Some(0x7034u16),
0x96c9 => Some(0x7035u16),
0x96cd => Some(0x7036u16),
0x894d => Some(0x7037u16),
0x96dc => Some(0x7038u16),
0x970d => Some(0x7039u16),
0x96d5 => Some(0x703au16),
0x96f9 => Some(0x703bu16),
0x9704 => Some(0x703cu16),
0x9706 => Some(0x703du16),
0x9708 => Some(0x703eu16),
0x9713 => Some(0x703fu16),
0x970e => Some(0x7040u16),
0x9711 => Some(0x7041u16),
0x970f => Some(0x7042u16),
0x9716 => Some(0x7043u16),
0x9719 => Some(0x7044u16),
0x9724 => Some(0x7045u16),
0x972a => Some(0x7046u16),
0x9730 => Some(0x7047u16),
0x9739 => Some(0x7048u16),
0x973d => Some(0x7049u16),
0x973e => Some(0x704au16),
0x9744 => Some(0x704bu16),
0x9746 => Some(0x704cu16),
0x9748 => Some(0x704du16),
0x9742 => Some(0x704eu16),
0x9749 => Some(0x704fu16),
0x975c => Some(0x7050u16),
0x9760 => Some(0x7051u16),
0x9764 => Some(0x7052u16),
0x9766 => Some(0x7053u16),
0x9768 => Some(0x7054u16),
0x52d2 => Some(0x7055u16),
0x976b => Some(0x7056u16),
0x9771 => Some(0x7057u16),
0x9779 => Some(0x7058u16),
0x9785 => Some(0x7059u16),
0x977c => Some(0x705au16),
0x9781 => Some(0x705bu16),
0x977a => Some(0x705cu16),
0x9786 => Some(0x705du16),
0x978b => Some(0x705eu16),
0x978f => Some(0x705fu16),
0x9790 => Some(0x7060u16),
0x979c => Some(0x7061u16),
0x97a8 => Some(0x7062u16),
0x97a6 => Some(0x7063u16),
0x97a3 => Some(0x7064u16),
0x97b3 => Some(0x7065u16),
0x97b4 => Some(0x7066u16),
0x97c3 => Some(0x7067u16),
0x97c6 => Some(0x7068u16),
0x97c8 => Some(0x7069u16),
0x97cb => Some(0x706au16),
0x97dc => Some(0x706bu16),
0x97ed => Some(0x706cu16),
0x9f4f => Some(0x706du16),
0x97f2 => Some(0x706eu16),
0x7adf => Some(0x706fu16),
0x97f6 => Some(0x7070u16),
0x97f5 => Some(0x7071u16),
0x980f => Some(0x7072u16),
0x980c => Some(0x7073u16),
0x9838 => Some(0x7074u16),
0x9824 => Some(0x7075u16),
0x9821 => Some(0x7076u16),
0x9837 => Some(0x7077u16),
0x983d => Some(0x7078u16),
0x9846 => Some(0x7079u16),
0x984f => Some(0x707au16),
0x984b => Some(0x707bu16),
0x986b => Some(0x707cu16),
0x986f => Some(0x707du16),
0x9870 => Some(0x707eu16),
0x9871 => Some(0x7121u16),
0x9874 => Some(0x7122u16),
0x9873 => Some(0x7123u16),
0x98aa => Some(0x7124u16),
0x98af => Some(0x7125u16),
0x98b1 => Some(0x7126u16),
0x98b6 => Some(0x7127u16),
0x98c4 => Some(0x7128u16),
0x98c3 => Some(0x7129u16),
0x98c6 => Some(0x712au16),
0x98e9 => Some(0x712bu16),
0x98eb => Some(0x712cu16),
0x9903 => Some(0x712du16),
0x9909 => Some(0x712eu16),
0x9912 => Some(0x712fu16),
0x9914 => Some(0x7130u16),
0x9918 => Some(0x7131u16),
0x9921 => Some(0x7132u16),
0x991d => Some(0x7133u16),
0x991e => Some(0x7134u16),
0x9924 => Some(0x7135u16),
0x9920 => Some(0x7136u16),
0x992c => Some(0x7137u16),
0x992e => Some(0x7138u16),
0x993d => Some(0x7139u16),
0x993e => Some(0x713au16),
0x9942 => Some(0x713bu16),
0x9949 => Some(0x713cu16),
0x9945 => Some(0x713du16),
0x9950 => Some(0x713eu16),
0x994b => Some(0x713fu16),
0x9951 => Some(0x7140u16),
0x9952 => Some(0x7141u16),
0x994c => Some(0x7142u16),
0x9955 => Some(0x7143u16),
0x9997 => Some(0x7144u16),
0x9998 => Some(0x7145u16),
0x99a5 => Some(0x7146u16),
0x99ad => Some(0x7147u16),
0x99ae => Some(0x7148u16),
0x99bc => Some(0x7149u16),
0x99df => Some(0x714au16),
0x99db => Some(0x714bu16),
0x99dd => Some(0x714cu16),
0x99d8 => Some(0x714du16),
0x99d1 => Some(0x714eu16),
0x99ed => Some(0x714fu16),
0x99ee => Some(0x7150u16),
0x99f1 => Some(0x7151u16),
0x99f2 => Some(0x7152u16),
0x99fb => Some(0x7153u16),
0x99f8 => Some(0x7154u16),
0x9a01 => Some(0x7155u16),
0x9a0f => Some(0x7156u16),
0x9a05 => Some(0x7157u16),
0x99e2 => Some(0x7158u16),
0x9a19 => Some(0x7159u16),
0x9a2b => Some(0x715au16),
0x9a37 => Some(0x715bu16),
0x9a45 => Some(0x715cu16),
0x9a42 => Some(0x715du16),
0x9a40 => Some(0x715eu16),
0x9a43 => Some(0x715fu16),
0x9a3e => Some(0x7160u16),
0x9a55 => Some(0x7161u16),
0x9a4d => Some(0x7162u16),
0x9a5b => Some(0x7163u16),
0x9a57 => Some(0x7164u16),
0x9a5f => Some(0x7165u16),
0x9a62 => Some(0x7166u16),
0x9a65 => Some(0x7167u16),
0x9a64 => Some(0x7168u16),
0x9a69 => Some(0x7169u16),
0x9a6b => Some(0x716au16),
0x9a6a => Some(0x716bu16),
0x9aad => Some(0x716cu16),
0x9ab0 => Some(0x716du16),
0x9abc => Some(0x716eu16),
0x9ac0 => Some(0x716fu16),
0x9acf => Some(0x7170u16),
0x9ad1 => Some(0x7171u16),
0x9ad3 => Some(0x7172u16),
0x9ad4 => Some(0x7173u16),
0x9ade => Some(0x7174u16),
0x9adf => Some(0x7175u16),
0x9ae2 => Some(0x7176u16),
0x9ae3 => Some(0x7177u16),
0x9ae6 => Some(0x7178u16),
0x9aef => Some(0x7179u16),
0x9aeb => Some(0x717au16),
0x9aee => Some(0x717bu16),
0x9af4 => Some(0x717cu16),
0x9af1 => Some(0x717du16),
0x9af7 => Some(0x717eu16),
0x9afb => Some(0x7221u16),
0x9b06 => Some(0x7222u16),
0x9b18 => Some(0x7223u16),
0x9b1a => Some(0x7224u16),
0x9b1f => Some(0x7225u16),
0x9b22 => Some(0x7226u16),
0x9b23 => Some(0x7227u16),
0x9b25 => Some(0x7228u16),
0x9b27 => Some(0x7229u16),
0x9b28 => Some(0x722au16),
0x9b29 => Some(0x722bu16),
0x9b2a => Some(0x722cu16),
0x9b2e => Some(0x722du16),
0x9b2f => Some(0x722eu16),
0x9b32 => Some(0x722fu16),
0x9b44 => Some(0x7230u16),
0x9b43 => Some(0x7231u16),
0x9b4f => Some(0x7232u16),
0x9b4d => Some(0x7233u16),
0x9b4e => Some(0x7234u16),
0x9b51 => Some(0x7235u16),
0x9b58 => Some(0x7236u16),
0x9b74 => Some(0x7237u16),
0x9b93 => Some(0x7238u16),
0x9b83 => Some(0x7239u16),
0x9b91 => Some(0x723au16),
0x9b96 => Some(0x723bu16),
0x9b97 => Some(0x723cu16),
0x9b9f => Some(0x723du16),
0x9ba0 => Some(0x723eu16),
0x9ba8 => Some(0x723fu16),
0x9bb4 => Some(0x7240u16),
0x9bc0 => Some(0x7241u16),
0x9bca => Some(0x7242u16),
0x9bb9 => Some(0x7243u16),
0x9bc6 => Some(0x7244u16),
0x9bcf => Some(0x7245u16),
0x9bd1 => Some(0x7246u16),
0x9bd2 => Some(0x7247u16),
0x9be3 => Some(0x7248u16),
0x9be2 => Some(0x7249u16),
0x9be4 => Some(0x724au16),
0x9bd4 => Some(0x724bu16),
0x9be1 => Some(0x724cu16),
0x9c3a => Some(0x724du16),
0x9bf2 => Some(0x724eu16),
0x9bf1 => Some(0x724fu16),
0x9bf0 => Some(0x7250u16),
0x9c15 => Some(0x7251u16),
0x9c14 => Some(0x7252u16),
0x9c09 => Some(0x7253u16),
0x9c13 => Some(0x7254u16),
0x9c0c => Some(0x7255u16),
0x9c06 => Some(0x7256u16),
0x9c08 => Some(0x7257u16),
0x9c12 => Some(0x7258u16),
0x9c0a => Some(0x7259u16),
0x9c04 => Some(0x725au16),
0x9c2e => Some(0x725bu16),
0x9c1b => Some(0x725cu16),
0x9c25 => Some(0x725du16),
0x9c24 => Some(0x725eu16),
0x9c21 => Some(0x725fu16),
0x9c30 => Some(0x7260u16),
0x9c47 => Some(0x7261u16),
0x9c32 => Some(0x7262u16),
0x9c46 => Some(0x7263u16),
0x9c3e => Some(0x7264u16),
0x9c5a => Some(0x7265u16),
0x9c60 => Some(0x7266u16),
0x9c67 => Some(0x7267u16),
0x9c76 => Some(0x7268u16),
0x9c78 => Some(0x7269u16),
0x9ce7 => Some(0x726au16),
0x9cec => Some(0x726bu16),
0x9cf0 => Some(0x726cu16),
0x9d09 => Some(0x726du16),
0x9d08 => Some(0x726eu16),
0x9ceb => Some(0x726fu16),
0x9d03 => Some(0x7270u16),
0x9d06 => Some(0x7271u16),
0x9d2a => Some(0x7272u16),
0x9d26 => Some(0x7273u16),
0x9daf => Some(0x7274u16),
0x9d23 => Some(0x7275u16),
0x9d1f => Some(0x7276u16),
0x9d44 => Some(0x7277u16),
0x9d15 => Some(0x7278u16),
0x9d12 => Some(0x7279u16),
0x9d41 => Some(0x727au16),
0x9d3f => Some(0x727bu16),
0x9d3e => Some(0x727cu16),
0x9d46 => Some(0x727du16),
0x9d48 => Some(0x727eu16),
0x9d5d => Some(0x7321u16),
0x9d5e => Some(0x7322u16),
0x9d64 => Some(0x7323u16),
0x9d51 => Some(0x7324u16),
0x9d50 => Some(0x7325u16),
0x9d59 => Some(0x7326u16),
0x9d72 => Some(0x7327u16),
0x9d89 => Some(0x7328u16),
0x9d87 => Some(0x7329u16),
0x9dab => Some(0x732au16),
0x9d6f => Some(0x732bu16),
0x9d7a => Some(0x732cu16),
0x9d9a => Some(0x732du16),
0x9da4 => Some(0x732eu16),
0x9da9 => Some(0x732fu16),
0x9db2 => Some(0x7330u16),
0x9dc4 => Some(0x7331u16),
0x9dc1 => Some(0x7332u16),
0x9dbb => Some(0x7333u16),
0x9db8 => Some(0x7334u16),
0x9dba => Some(0x7335u16),
0x9dc6 => Some(0x7336u16),
0x9dcf => Some(0x7337u16),
0x9dc2 => Some(0x7338u16),
0x9dd9 => Some(0x7339u16),
0x9dd3 => Some(0x733au16),
0x9df8 => Some(0x733bu16),
0x9de6 => Some(0x733cu16),
0x9ded => Some(0x733du16),
0x9def => Some(0x733eu16),
0x9dfd => Some(0x733fu16),
0x9e1a => Some(0x7340u16),
0x9e1b => Some(0x7341u16),
0x9e1e => Some(0x7342u16),
0x9e75 => Some(0x7343u16),
0x9e79 => Some(0x7344u16),
0x9e7d => Some(0x7345u16),
0x9e81 => Some(0x7346u16),
0x9e88 => Some(0x7347u16),
0x9e8b => Some(0x7348u16),
0x9e8c => Some(0x7349u16),
0x9e92 => Some(0x734au16),
0x9e95 => Some(0x734bu16),
0x9e91 => Some(0x734cu16),
0x9e9d => Some(0x734du16),
0x9ea5 => Some(0x734eu16),
0x9ea9 => Some(0x734fu16),
0x9eb8 => Some(0x7350u16),
0x9eaa => Some(0x7351u16),
0x9ead => Some(0x7352u16),
0x9761 => Some(0x7353u16),
0x9ecc => Some(0x7354u16),
0x9ece => Some(0x7355u16),
0x9ecf => Some(0x7356u16),
0x9ed0 => Some(0x7357u16),
0x9ed4 => Some(0x7358u16),
0x9edc => Some(0x7359u16),
0x9ede => Some(0x735au16),
0x9edd => Some(0x735bu16),
0x9ee0 => Some(0x735cu16),
0x9ee5 => Some(0x735du16),
0x9ee8 => Some(0x735eu16),
0x9eef => Some(0x735fu16),
0x9ef4 => Some(0x7360u16),
0x9ef6 => Some(0x7361u16),
0x9ef7 => Some(0x7362u16),
0x9ef9 => Some(0x7363u16),
0x9efb => Some(0x7364u16),
0x9efc => Some(0x7365u16),
0x9efd => Some(0x7366u16),
0x9f07 => Some(0x7367u16),
0x9f08 => Some(0x7368u16),
0x76b7 => Some(0x7369u16),
0x9f15 => Some(0x736au16),
0x9f21 => Some(0x736bu16),
0x9f2c => Some(0x736cu16),
0x9f3e => Some(0x736du16),
0x9f4a => Some(0x736eu16),
0x9f52 => Some(0x736fu16),
0x9f54 => Some(0x7370u16),
0x9f63 => Some(0x7371u16),
0x9f5f => Some(0x7372u16),
0x9f60 => Some(0x7373u16),
0x9f61 => Some(0x7374u16),
0x9f66 => Some(0x7375u16),
0x9f67 => Some(0x7376u16),
0x9f6c => Some(0x7377u16),
0x9f6a => Some(0x7378u16),
0x9f77 => Some(0x7379u16),
0x9f72 => Some(0x737au16),
0x9f76 => Some(0x737bu16),
0x9f95 => Some(0x737cu16),
0x9f9c => Some(0x737du16),
0x9fa0 => Some(0x737eu16),
0x582f => Some(0x7421u16),
0x69c7 => Some(0x7422u16),
0x9059 => Some(0x7423u16),
0x7464 => Some(0x7424u16),
0x51dc => Some(0x7425u16),
0x7199 => Some(0x7426u16),
_ => None
}
}
| 444
|
fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
paths.iter().any(|candidate| match_qpath(path, candidate))
}
| 445
|
fn main() {
env_logger::init_from_env(env_logger::Env::default().default_filter_or("info"));
spawn(
serde_json::to_vec,
|bytes| serde_json::from_slice(bytes),
vec![
(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 3000), ServerActor)
]).unwrap();
}
| 446
|
pub fn assignable(node: Node) -> Node {
println!("DEBUGGING node::assignable: {:?}", node);
match node {
Node::Ident(ident) => {
// name, = *node
// @parser.static_env.declare(name)
//
// node.updated(:lVasgn)
// TODO handle appending nodes list
// TODO handle static_env
return Node::LVasgn(ident, vec![]);
},
_ => { panic!("node::assignable: UNIMPL branch"); }
}
}
| 447
|
pub fn build_wix_app_installer(
settings: &Settings,
wix_toolset_path: &Path,
) -> crate::Result<PathBuf> {
let arch = match settings.binary_arch() {
"x86_64" => "x64",
"x86" => "x86",
target => {
return Err(crate::Error::ArchError(format!(
"unsupported target: {}",
target
)))
}
};
// target only supports x64.
common::print_info(format!("Target: {}", arch).as_str())?;
let output_path = settings
.project_out_directory()
.join("bundle/msi")
.join(arch);
let mut data = BTreeMap::new();
if let Ok(tauri_config) = crate::bundle::tauri_config::get() {
data.insert(
"embedded_server",
to_json(tauri_config.tauri.embedded_server.active),
);
}
data.insert("product_name", to_json(settings.bundle_name()));
data.insert("version", to_json(settings.version_string()));
let manufacturer = settings.bundle_identifier().to_string();
data.insert("manufacturer", to_json(manufacturer.as_str()));
let upgrade_code = Uuid::new_v5(
&Uuid::NAMESPACE_DNS,
format!("{}.app.x64", &settings.main_binary_name()).as_bytes(),
)
.to_string();
data.insert("upgrade_code", to_json(&upgrade_code.as_str()));
let path_guid = generate_package_guid(settings).to_string();
data.insert("path_component_guid", to_json(&path_guid.as_str()));
let shortcut_guid = generate_package_guid(settings).to_string();
data.insert("shortcut_guid", to_json(&shortcut_guid.as_str()));
let app_exe_name = settings.main_binary_name().to_string();
data.insert("app_exe_name", to_json(&app_exe_name));
let binaries = generate_binaries_data(&settings)?;
let binaries_json = to_json(&binaries);
data.insert("binaries", binaries_json);
let resources = generate_resource_data(&settings)?;
let mut resources_wix_string = String::from("");
let mut files_ids = Vec::new();
for (_, dir) in resources {
let (wix_string, ids) = dir.get_wix_data()?;
resources_wix_string.push_str(wix_string.as_str());
for id in ids {
files_ids.push(id);
}
}
data.insert("resources", to_json(resources_wix_string));
data.insert("resource_file_ids", to_json(files_ids));
let main_binary = settings
.binaries()
.iter()
.find(|bin| bin.main())
.ok_or_else(|| anyhow::anyhow!("Failed to get main binary"))?;
let app_exe_source = settings.binary_path(main_binary).display().to_string();
data.insert("app_exe_source", to_json(&app_exe_source));
// copy icons from icons folder to resource folder near msi
let image_path = copy_icons(&settings)?;
let path = image_path.join("icon.ico").display().to_string();
data.insert("icon_path", to_json(path.as_str()));
let temp = HANDLEBARS.render("main.wxs", &data)?;
if output_path.exists() {
remove_dir_all(&output_path).or_else(|e| Err(e))?;
}
create_dir_all(&output_path).or_else(|e| Err(e))?;
let main_wxs_path = output_path.join("main.wxs");
write(&main_wxs_path, temp).or_else(|e| Err(e))?;
let input_basenames = vec!["main"];
for basename in &input_basenames {
let wxs = format!("{}.wxs", basename);
run_candle(settings, &wix_toolset_path, &output_path, &wxs)?;
}
let wixobjs = vec!["main.wixobj"];
let target = run_light(
&wix_toolset_path,
&output_path,
&wixobjs,
&app_installer_dir(settings)?,
)?;
Ok(target)
}
| 448
|
fn map_message(tok: IRCToken) -> Result<IRCToken, ~str> {
// Sequence(~[Sequence(~[Sequence(~[Unparsed(~":"), PrefixT(irc::Prefix{nick: ~"tiffany", user: ~"lymia", host: ~"hugs"}), Ignored])]), Unparsed(~"PRIVMSG"), Sequence(~[Params(~[~"##codelab", ~"hi"])])])
match tok {
Sequence([Sequence([Sequence([Unparsed(~":"), PrefixT(prefix), Ignored])]), Unparsed(cmd), Sequence([Params(params)])]) =>
Ok(MessageT(Message {prefix: Some(prefix), command: cmd, params: params})),
Sequence([Sequence([]), Unparsed(cmd), Sequence([Params(params)])]) =>
Ok(MessageT(Message {prefix: None, command: cmd, params: params})),
_ => Err(fmt!("Malformed message: %?", tok))
}
}
| 449
|
pub fn write_nfix<W>(wr: &mut W, val: i8) -> Result<(), FixedValueWriteError>
where W: Write
{
assert!(-32 <= val && val < 0);
write_fixval(wr, Marker::FixNeg(val))
}
| 450
|
fn figure_1c() {
const COUNT: usize = 4usize;
// n=2, k=2*14, d=2, so probability of finding the bug is at least 1/(2*28)
// So probability of hitting the bug in 400 iterations = 1 - (1 - 1/56)^400 > 99.9%
let scheduler = PctScheduler::new(2, 400);
let runner = Runner::new(scheduler, Default::default());
runner.run(|| {
let a1 = Arc::new(Mutex::new(0));
let a2 = Arc::clone(&a1);
let b1 = Arc::new(Mutex::new(0));
let b2 = Arc::clone(&b1);
thread::spawn(move || {
for _ in 0..COUNT {
thread::sleep(Duration::from_millis(1));
}
let a = a1.lock().unwrap();
for _ in 0..COUNT {
thread::sleep(Duration::from_millis(1));
}
let b = b1.lock().unwrap();
for _ in 0..COUNT {
thread::sleep(Duration::from_millis(1));
}
assert_eq!(*a + *b, 0)
});
thread::spawn(move || {
for _ in 0..COUNT {
thread::sleep(Duration::from_millis(1));
}
let b = b2.lock().unwrap();
for _ in 0..COUNT {
thread::sleep(Duration::from_millis(1));
}
let a = a2.lock().unwrap();
for _ in 0..COUNT {
thread::sleep(Duration::from_millis(1));
}
assert_eq!(*a + *b, 0);
});
});
}
| 451
|
async fn get_historic_trades() {
let exchange = init().await;
let req = GetHistoricTradesRequest {
market_pair: "eth_btc".to_string(),
paginator: Some(Paginator {
limit: Some(100),
..Default::default()
}),
};
let resp = exchange.get_historic_trades(&req).await.unwrap();
println!("{:?}", resp);
}
| 452
|
pub fn day09_2(s: String) -> u32{
let mut running_total = 0;
let mut in_garbage = false;
let mut prev_cancel = false;
for c in s.chars(){
if in_garbage {
if c == '>' && !prev_cancel {
in_garbage = false;
prev_cancel = false;
}
else if c == '!' && !prev_cancel {
prev_cancel = true;
}
else if !prev_cancel{
running_total+=1;
}
else {
prev_cancel = false;
}
}
else{
if c == '<' {
in_garbage = true;
prev_cancel = false;
}
}
}
running_total
}
| 453
|
fn roll(die: i32) -> i32 {
let mut rng = rand::thread_rng();
rng.gen_range(1, die)
}
| 454
|
fn invoke_rustdoc(
builder: &Builder<'_>,
compiler: Compiler,
target: Interned<String>,
markdown: &str,
) {
let out = builder.doc_out(target);
let path = builder.src.join("src/doc").join(markdown);
let header = builder.src.join("src/doc/redirect.inc");
let footer = builder.src.join("src/doc/footer.inc");
let version_info = out.join("version_info.html");
let mut cmd = builder.rustdoc_cmd(compiler);
let out = out.join("book");
cmd.arg("--html-after-content").arg(&footer)
.arg("--html-before-content").arg(&version_info)
.arg("--html-in-header").arg(&header)
.arg("--markdown-no-toc")
.arg("--markdown-playground-url").arg("https://play.rust-lang.org/")
.arg("-o").arg(&out).arg(&path)
.arg("--markdown-css").arg("../rust.css");
builder.run(&mut cmd);
}
| 455
|
fn build_stripping_dead_code() {
let project = project("build_strip").with_fuzz().build();
// Create some targets.
project
.cargo_fuzz()
.arg("add")
.arg("build_strip_a")
.assert()
.success();
project
.cargo_fuzz()
.arg("build")
.arg("--strip-dead-code")
.arg("--dev")
.assert()
.success();
let build_dir = project.fuzz_build_dir().join("debug");
let a_bin = build_dir.join("build_strip_a");
assert!(a_bin.is_file(), "Not a file: {}", a_bin.display());
}
| 456
|
pub fn quick_sort<T: PartialOrd + Debug>(v: &mut [T]) {
if v.len() <= 1 {
return;
}
let p = pivot(v);
println!("{:?}", v);
let (a, b) = v.split_at_mut(p);
quick_sort(a);
quick_sort(&mut b[1..]);
}
| 457
|
fn mailmap_from_repo(repo: &git2::Repository) -> Result<Mailmap, Box<dyn std::error::Error>> {
let file = String::from_utf8(
repo.revparse_single("master")?
.peel_to_commit()?
.tree()?
.get_name(".mailmap")
.unwrap()
.to_object(&repo)?
.peel_to_blob()?
.content()
.into(),
)?;
Mailmap::from_string(file)
}
| 458
|
fn parse_bors_reviewer(
reviewers: &Reviewers,
repo: &Repository,
commit: &Commit,
) -> Result<Option<Vec<Author>>, ErrorContext> {
if commit.author().name_bytes() != b"bors" || commit.committer().name_bytes() != b"bors" {
if commit.committer().name_bytes() != b"GitHub" || !is_rollup_commit(commit) {
return Ok(None);
}
}
// Skip non-merge commits
if commit.parents().count() == 1 {
return Ok(None);
}
let to_author = |list: &str| -> Result<Vec<Author>, ErrorContext> {
list.trim_end_matches('.')
.split(|c| c == ',' || c == '+')
.map(|r| r.trim_start_matches('@'))
.map(|r| r.trim_end_matches('`'))
.map(|r| r.trim())
.filter(|r| !r.is_empty())
.filter(|r| *r != "<try>")
.inspect(|r| {
if !r.chars().all(|c| {
c.is_alphabetic() || c.is_digit(10) || c == '-' || c == '_' || c == '='
}) {
eprintln!(
"warning: to_author for {} contained non-alphabetic characters: {:?}",
commit.id(),
r
);
}
})
.map(|r| {
reviewers.to_author(r).map_err(|e| {
ErrorContext(
format!("reviewer: {:?}, commit: {}", r, commit.id()),
e.into(),
)
})
})
.flat_map(|r| r.transpose())
.collect::<Result<Vec<_>, ErrorContext>>()
};
let message = commit.message().unwrap_or("");
let mut reviewers = if let Some(line) = message.lines().find(|l| l.contains(" r=")) {
let start = line.find("r=").unwrap() + 2;
let end = line[start..]
.find(' ')
.map(|pos| pos + start)
.unwrap_or(line.len());
to_author(&line[start..end])?
} else if let Some(line) = message.lines().find(|l| l.starts_with("Reviewed-by: ")) {
let line = &line["Reviewed-by: ".len()..];
to_author(&line)?
} else {
// old bors didn't include r=
if message != "automated merge\n" {
panic!(
"expected reviewer for bors merge commit {} in {:?}, message: {:?}",
commit.id(),
repo.path(),
message
);
}
return Ok(None);
};
reviewers.sort();
reviewers.dedup();
Ok(Some(reviewers))
}
| 459
|
fn arity_is_preserved_when_generating_data_model_from_a_schema() {
let ref_data_model = Datamodel {
models: vec![Model {
database_name: None,
name: "Table1".to_string(),
documentation: None,
is_embedded: false,
is_commented_out: false,
fields: vec![
Field::ScalarField(ScalarField::new(
"optional",
FieldArity::Optional,
FieldType::Base(ScalarType::Int, None),
)),
Field::ScalarField(ScalarField {
name: "required".to_string(),
arity: FieldArity::Required,
field_type: FieldType::Base(ScalarType::Int, None),
database_name: None,
default_value: Some(DMLDefault::Expression(ValueGenerator::new_autoincrement())),
is_unique: false,
is_id: true,
documentation: None,
is_generated: false,
is_updated_at: false,
is_commented_out: false,
}),
Field::ScalarField(ScalarField::new(
"list",
FieldArity::List,
FieldType::Base(ScalarType::Int, None),
)),
],
is_generated: false,
indices: vec![],
id_fields: vec![],
}],
enums: vec![],
};
let schema = SqlSchema {
tables: vec![Table {
name: "Table1".to_string(),
columns: vec![
Column {
name: "optional".to_string(),
tpe: ColumnType::pure(ColumnTypeFamily::Int, ColumnArity::Nullable),
default: None,
auto_increment: false,
},
Column {
name: "required".to_string(),
tpe: ColumnType::pure(ColumnTypeFamily::Int, ColumnArity::Required),
default: None,
auto_increment: true,
},
Column {
name: "list".to_string(),
tpe: ColumnType::pure(ColumnTypeFamily::Int, ColumnArity::List),
default: None,
auto_increment: false,
},
],
indices: vec![],
primary_key: Some(PrimaryKey {
columns: vec!["required".to_string()],
sequence: None,
constraint_name: None,
}),
foreign_keys: vec![],
}],
enums: vec![],
sequences: vec![],
};
let introspection_result = calculate_datamodel(&schema, &SqlFamily::Postgres).expect("calculate data model");
assert_eq!(introspection_result.data_model, ref_data_model);
}
| 460
|
async fn main() {
tracing_subscriber::registry()
.with(
tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| {
// axum logs rejections from built-in extractors with the `axum::rejection`
// target, at `TRACE` level. `axum::rejection=trace` enables showing those events
"example_tracing_aka_logging=debug,tower_http=debug,axum::rejection=trace".into()
}),
)
.with(tracing_subscriber::fmt::layer())
.init();
// build our application with a route
let app = Router::new()
.route("/", get(handler))
// `TraceLayer` is provided by tower-http so you have to add that as a dependency.
// It provides good defaults but is also very customizable.
//
// See https://docs.rs/tower-http/0.1.1/tower_http/trace/index.html for more details.
//
// If you want to customize the behavior using closures here is how.
.layer(
TraceLayer::new_for_http()
.make_span_with(|request: &Request<_>| {
// Log the matched route's path (with placeholders not filled in).
// Use request.uri() or OriginalUri if you want the real path.
let matched_path = request
.extensions()
.get::<MatchedPath>()
.map(MatchedPath::as_str);
info_span!(
"http_request",
method = ?request.method(),
matched_path,
some_other_field = tracing::field::Empty,
)
})
.on_request(|_request: &Request<_>, _span: &Span| {
// You can use `_span.record("some_other_field", value)` in one of these
// closures to attach a value to the initially empty field in the info_span
// created above.
})
.on_response(|_response: &Response, _latency: Duration, _span: &Span| {
// ...
})
.on_body_chunk(|_chunk: &Bytes, _latency: Duration, _span: &Span| {
// ...
})
.on_eos(
|_trailers: Option<&HeaderMap>, _stream_duration: Duration, _span: &Span| {
// ...
},
)
.on_failure(
|_error: ServerErrorsFailureClass, _latency: Duration, _span: &Span| {
// ...
},
),
);
// run it
let listener = TcpListener::bind("127.0.0.1:3000").await.unwrap();
tracing::debug!("listening on {}", listener.local_addr().unwrap());
axum::serve(listener, app).await.unwrap();
}
| 461
|
pub extern "x86-interrupt" fn floppy() { CommonInterruptHandler(38); }
| 462
|
pub fn allow_debug() -> bool {
let self_report = create_report(None, None).expect("create a self report should never fail");
(self_report.body.attributes.flags & SGX_FLAGS_DEBUG) == SGX_FLAGS_DEBUG
}
| 463
|
fn main() {
if let Err(err) = Config::new().and_then(|conf| ui::user_menu(conf)) {
eprintln!("{}", err);
process::exit(1);
}
}
| 464
|
fn modified_file() {
fn just_read(mut file: IoResult<File>) -> IoResult<Option<Vec<u8>>> {
file.read_to_end().map(|v| Some(v))
}
let file = CachedProcessedFile::new(Path::new("LICENSE"), None, just_read);
assert_eq!(file.expired(), true);
assert!(file.borrow().as_ref().map(|v| v.len()).unwrap_or(0) > 0);
assert_eq!(file.expired(), false);
file.free();
assert_eq!(file.expired(), true);
}
| 465
|
fn inc_19() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Direct(ECX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 65], OperandSize::Word)
}
| 466
|
pub fn write_f32<W>(wr: &mut W, val: f32) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_marker(wr, Marker::F32));
write_data_f32(wr, val)
}
| 467
|
fn check_coordinates(x : i32, y : i32) -> bool {
return 0 <= x && x < 640 && 0 <= y && y < 480;
}
| 468
|
pub fn causet_partitioner_request_new(prev_user_soliton_id: &[u8], current_user_soliton_id: &[u8], current_output_file_size: u64) -> Box<CausetPartitionerRequest> {
Box::new(CausetPartitionerRequest {
prev_user_soliton_id,
current_user_soliton_id,
current_output_file_size,
})
}
| 469
|
fn copy_test() {
{
/*
struct Label {
number: u32,
}
fn print(l: Label) {
println!("STAMP: {}", l.number);
}
let l = Label { number: 3 };
print(l);
println!("My label number is: {}", l.number); // error
*/
#[derive(Copy, Clone)]
struct Label {
number: u32,
}
fn print(l: Label) {
println!("STAMP: {}", l.number);
}
let l = Label { number: 3 };
print(l);
println!("My label number is: {}", l.number);
/*
#[derive(Copy, Clone)]
struct StringLabel {
name: String,
}
*/
}
}
| 470
|
fn debg(t: impl Debug) -> String {
format!("{:?}", t)
}
| 471
|
fn fist_3() {
run_test(&Instruction { mnemonic: Mnemonic::FIST, operand1: Some(IndirectScaledDisplaced(RSI, Two, 1869896401, Some(OperandSize::Dword), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[219, 20, 117, 209, 90, 116, 111], OperandSize::Qword)
}
| 472
|
fn tokenize_line(line: &str) -> Result<Command, CueError> {
let mut chars = line.trim().chars();
let command = next_token(&mut chars);
let command = if command.is_empty() {
None
} else {
Some(command)
};
match command {
Some(c) => match c.to_uppercase().as_ref() {
"REM" => {
let key = next_token(&mut chars);
let val = next_string(&mut chars, "missing REM value")?;
Ok(Command::Rem(key, val))
}
"CATALOG" => {
let val = next_string(&mut chars, "missing CATALOG value")?;
Ok(Command::Catalog(val))
}
"CDTEXTFILE" => {
let val = next_string(&mut chars, "missing CDTEXTFILE value")?;
Ok(Command::CdTextFile(val))
}
"TITLE" => {
let val = next_string(&mut chars, "missing TITLE value")?;
Ok(Command::Title(val))
}
"FILE" => {
let path = next_string(&mut chars, "missing path for FILE")?;
let format = next_token(&mut chars);
Ok(Command::File(path, format))
}
"FLAGS" => {
let flags = next_values(&mut chars);
Ok(Command::Flags(flags))
}
"ISRC" => {
let val = next_token(&mut chars);
Ok(Command::Isrc(val))
}
"PERFORMER" => {
let val = next_string(&mut chars, "missing PERFORMER value")?;
Ok(Command::Performer(val))
}
"SONGWRITER" => {
let val = next_string(&mut chars, "missing SONGWRITER value")?;
Ok(Command::Songwriter(val))
}
"TRACK" => {
let val = next_token(&mut chars);
let mode = next_token(&mut chars);
Ok(Command::Track(val, mode))
}
"PREGAP" => {
let val = next_token(&mut chars);
Ok(Command::Pregap(val))
}
"POSTGAP" => {
let val = next_token(&mut chars);
Ok(Command::Postgap(val))
}
"INDEX" => {
let val = next_token(&mut chars);
let time = next_token(&mut chars);
Ok(Command::Index(val, time))
}
_ => {
let rest: String = chars.collect();
if rest.is_empty() {
Ok(Command::None)
} else {
Ok(Command::Unknown(line.to_string()))
}
}
},
_ => Ok(Command::None),
}
}
| 473
|
pub fn spl_op(inputs: OpInputs) -> EmulatorResult<()> {
// SPL queues the next instruction (PC + 1) and then queues the sum of the
// program counter and A-pointer. If the queue is full, only the next
// instruction is queued.
let next_pc = offset(inputs.regs.current.idx, 1, inputs.core_size);
inputs.pq.push_back(next_pc?, inputs.warrior_id)?;
inputs.pq.push_back(inputs.regs.a.idx, inputs.warrior_id)?;
Ok(())
}
| 474
|
unsafe
fn
atomic_load
<
T
>
(
src
:
*
mut
T
)
-
>
T
where
T
:
Copy
{
atomic
!
{
T
a
{
a
=
&
*
(
src
as
*
const
_
as
*
const
_
)
;
mem
:
:
transmute_copy
(
&
a
.
load
(
Ordering
:
:
Acquire
)
)
}
{
let
lock
=
lock
(
src
as
usize
)
;
/
/
Try
doing
an
optimistic
read
first
.
if
let
Some
(
stamp
)
=
lock
.
optimistic_read
(
)
{
/
/
We
need
a
volatile
read
here
because
other
threads
might
concurrently
modify
the
/
/
value
.
In
theory
data
races
are
*
always
*
UB
even
if
we
use
volatile
reads
and
/
/
discard
the
data
when
a
data
race
is
detected
.
The
proper
solution
would
be
to
/
/
do
atomic
reads
and
atomic
writes
but
we
can
'
t
atomically
read
and
write
all
/
/
kinds
of
data
since
AtomicU8
is
not
available
on
stable
Rust
yet
.
/
/
Load
as
MaybeUninit
because
we
may
load
a
value
that
is
not
valid
as
T
.
let
val
=
ptr
:
:
read_volatile
(
src
.
cast
:
:
<
MaybeUninit
<
T
>
>
(
)
)
;
if
lock
.
validate_read
(
stamp
)
{
return
val
.
assume_init
(
)
;
}
}
/
/
Grab
a
regular
write
lock
so
that
writers
don
'
t
starve
this
load
.
let
guard
=
lock
.
write
(
)
;
let
val
=
ptr
:
:
read
(
src
)
;
/
/
The
value
hasn
'
t
been
changed
.
Drop
the
guard
without
incrementing
the
stamp
.
guard
.
abort
(
)
;
val
}
}
}
| 475
|
fn get_platform() -> Platform {
match env::var("TARGET").unwrap().split('-').nth(2).unwrap() {
"win32" | "windows" => Platform::Windows,
"darwin" => Platform::Mac,
"linux" => Platform::Linux,
other => panic!("Sorry, platform \"{}\" is not supported by CEF.", other),
}
}
| 476
|
fn start_tracking(interface: &NetworkInterface, just_me: bool) {
let mut pt = PacketTracker::new(interface.clone(), just_me);
// Create a new channel, dealing with layer 2 packets
let (_tx, mut rx) = match datalink::channel(&interface, Default::default()) {
Ok(Ethernet(tx, rx)) => (tx, rx),
Ok(_) => panic!("Unhandled channel type"),
Err(e) => panic!(
"An error occurred when creating the datalink channel: {}",
e
),
};
//print_thread(&pt);
//let mut count = 0;
let mut start_counting_time = SystemTime::now();
loop {
//count += 1;
/*if count > 30 {
break
}*/
match rx.next() {
Ok(packet) => {
let packet = EthernetPacket::new(packet).unwrap();
pt.inspect_packet(packet);
}
Err(e) => {
// If an error occurs, we can handle it here
panic!("An error occurred while reading: {}", e);
}
}
if start_counting_time + Duration::new(5, 0) < SystemTime::now() {
pt.pretty_out(&start_counting_time);
start_counting_time = SystemTime::now()
}
}
}
| 477
|
pub fn check_mmap_ptr(ptr: Ptr) -> io::Result<Ptr> {
if ptr == -1 as isize as *mut c_void {
let err = errno();
Err(io::Error::new(io::ErrorKind::Other, format!("mmap failed: [{}] {}", err.0, err)))
} else {
Ok(ptr)
}
}
| 478
|
fn enum_test() {
// enum Ordering {
// Less,
// Equal,
// Greater / 2.0
// }
use std::cmp::Ordering;
fn compare(n: i32, m: i32) -> Ordering {
if n < m {
Ordering::Less
} else if n > m {
Ordering::Greater
} else {
Ordering::Equal
}
}
// use std::cmp::Ordering::*;
// fn compare(n: i32, m: i32) -> Ordering {
// if n < m {
// Less
// } else if n > m {
// Greater
// } else {
// Equal
// }
// }
// enum Pet {
// Orca,
// Giraffe,
// }
// use self::Pet::*;
#[derive(Debug, PartialEq)]
enum HttpStatus {
Ok = 200,
NotModified = 304,
NotFound = 404,
}
use std::mem::size_of;
assert_eq!(size_of::<Ordering>(), 1);
assert_eq!(size_of::<HttpStatus>(), 2); // 404 doesn't fit in a u8
assert_eq!(HttpStatus::Ok as i32, 200);
fn http_status_from_u32(n: u32) -> Option<HttpStatus> {
match n {
200 => Some(HttpStatus::Ok),
304 => Some(HttpStatus::NotModified),
404 => Some(HttpStatus::NotFound),
_ => None,
}
}
let status = http_status_from_u32(404).unwrap();
// assert_eq!(status as i32, 404);
assert_eq!(status, HttpStatus::NotFound);
#[derive(Copy, Clone, Debug, PartialEq)]
enum TimeUnit {
Seconds,
Minutes,
Hours,
Days,
Months,
Years,
}
impl TimeUnit {
/// Return the plural noun for this time unit.
fn plural(self) -> &'static str {
match self {
TimeUnit::Seconds => "seconds",
TimeUnit::Minutes => "minutes",
TimeUnit::Hours => "hours",
TimeUnit::Days => "days",
TimeUnit::Months => "months",
TimeUnit::Years => "years",
}
}
/// Return the singular noun for this time unit.
fn singular(self) -> &'static str {
self.plural().trim_right_matches('s')
}
}
/// A timestamp that has been deliberately rounded off, so our program
/// says "6 monthes ago" instead of "February 9, 2016, at 9:49 AM".
#[derive(Copy, Clone, Debug, PartialEq)]
enum RoughTime {
InThePast(TimeUnit, u32),
JustNow,
InTheFuture(TimeUnit, u32),
}
let four_score_and_seven_years_ago = RoughTime::InThePast(TimeUnit::Years, 4 * 20 + 7);
let three_hours_from_now = RoughTime::InTheFuture(TimeUnit::Hours, 3);
struct Point3d(u32, u32, u32);
enum Shape {
Sphere { center: Point3d, radius: f32 },
Cubold { corner1: Point3d, corner2: Point3d },
}
let unit_sphere = Shape::Sphere {
center: Point3d(0, 0, 0),
radius: 1.0,
};
// enum RelationshipStatus {
// Single,
// InARelationship,
// ItsComplicated(Option<String>),
// ItsExtremelyComplicated {
// car: DifferentialEquation,
// cdr: EarlyModernistPoem
// }
// }
//
use std::collections::HashMap;
enum Json {
Null,
Boolean(bool),
Number(f64),
String(String),
Array(Vec<Json>),
Object(Box<HashMap<String, Json>>),
}
// An ordered collection of `T`s
enum BinaryTree<T> {
Empty,
NonEmpty(Box<TreeNode<T>>),
}
// A part of a BinaryTree.
struct TreeNode<T> {
element: T,
left: BinaryTree<T>,
right: BinaryTree<T>,
}
let jupiter_tree = BinaryTree::NonEmpty(Box::new(TreeNode {
element: "Jupiter",
left: BinaryTree::Empty,
right: BinaryTree::Empty,
}));
let mercury_tree = BinaryTree::NonEmpty(Box::new(TreeNode {
element: "Mercury",
left: BinaryTree::Empty,
right: BinaryTree::Empty,
}));
let uranus_tree = BinaryTree::NonEmpty(Box::new(TreeNode {
element: "Uranus",
left: BinaryTree::Empty,
right: BinaryTree::Empty,
}));
let mars_tree = BinaryTree::NonEmpty(Box::new(TreeNode {
element: "Mars",
left: jupiter_tree,
right: mercury_tree,
}));
let tree = BinaryTree::NonEmpty(Box::new(TreeNode {
element: "Saturn",
left: mars_tree,
right: uranus_tree,
}));
// let mut tree = BinaryTree::Empty;
// for planet in planets {
// tree.add(planet);
// }
// 10.2
fn rough_time_to_english(rt: RoughTime) -> String {
match rt {
RoughTime::InThePast(units, count) => format!("{}, {} ago", count, units.plural()),
RoughTime::JustNow => format!("just now"),
RoughTime::InTheFuture(units, 1) => format!("a {} from now", units.plural()),
RoughTime::InTheFuture(units, count) => {
format!("{}, {} from now", count, units.plural())
}
}
}
rough_time_to_english(four_score_and_seven_years_ago);
// 10.2.1
// match meadow.count_rabbits() {
// 0 => {} // nothing to say
// 1 => println!("A rabbit is nosing around inthe clover."),
// n => println!("There are {} rabbits hopping about in the meadow", n)
// }
//
// let calendar =
// match settings.get_string("calendar") {
// "gregorian" => Calendar::Gregorian,
// "chinese" => Calendar::Chinese,
// "ethiopian" => Calendar::Ethiopian,
// other => return parse_error("calendar", other)
// };
// let caption =
// match photo.tagged_pet() {
// Pet::Tyrannosaur => "RRRRAAAAAHHHHH",
// Pet::Samoyed => "*dog thoughts*",
// _ => "I'm cute, love me" // generic caption, works for any pet
// }
// // there are many Shapes, but we only support "selecting"
// // either some text, or everything in a rectangular area.
// // You can't select an ellipse or trapezoid.
// match document.selection() {
// Shape::TextSpan(start, end) => paint_text_selection(start, end),
// Shape::Rectangle(rect) => paint_rect_selection(rect),
// _ => panic!("unexpected selection type")
// }
//
// fn check_move(current_hex: Hex, click: Point) -> game::Result<Hex> {
// match point_to_hex(click) {
// None =>
// Err("That's not a game space."),
// Some(current_hex) => // try to match if user clicked the current_hex
// // (if doesn't work)
// Err("You are already there! You must click somewhere else."),
// Some(other_hex) =>
// Ok(other_hex)
// }
// }
//
// fn check_move(current_hex: Hex, click: Point) -> game::Result<Hex> {
// match point_to_hex(click) {
// None =>
// Err("That's not a game space."),
// Some(hex) =>
// if hex == current_hex {
// Err("You are already there! You must click somewhere else."),
// } else {
// Ok(hex)
// }
// Some(other_hex) =>
// Ok(other_hex)
// }
// }
//
// fn describe_point(x: i32, y: i32) -> &'static str {
// use std::cmp::Ordering::*;
// match (x.cmp(&0), y.cmp(&0) {
// (Equal, Equal) -> "at the origin",
// (_, Equal) => "on the x axis",
// (Equal, _) => "on the y axis",
// (Greater, Greater) => "in the first quadrant",
// (Less, Grater) => "in the second quadrant",
// _ => "somewhere else"
// }
// }
//
// match balloon.location {
// Point { x: 0, y: height } =>
// println!("straight up {} meters", height),
// Point { x: x, y: y } =>
// println!("at ({}m, {}m)", x, y);
// }
//
// match get_acount(id) {
// Some(Account { name, language, .. {) =>
// language.show_custom_greeting(name)
// }
//
// 10.2.3
//
// match account {
// Account { name, language, .. } => {
// ui.greet(&name, &language);
// ui.show_settigs(&account); // error: use of moved value `account`
// }
// }
// match account {
// Account { ref name, ref language, .. } => {
// ui.greet(name, language);
// ui.show_settings(&account); // ok
// }
// }
//
// match line_result {
// Err(ref err) => log_error(err), // `err` is &Error (shared ref)
// Ok(ref mut line) -> { // `line` is &mut String (mut ref)
// trim_comments(line); // modify the String in place
// handle(line);
// }
// }
//
// match sphere.center() {
// &Point3d { x, y, z } => ...
// }
//
// match friend.borrow_car() {
// Some(&Car { engine, .. }) => // error: can't move out of borrow
// ...
// None -> {}
// }
//
// Some(&Car {ref engine, .. }) => // ok, engine is a reference
//
// match chars.peek() {
// Some(&c) -> println!("coming up: {:?}", c),
// None =-> println!("end of chars")
// }
//
// 10.2.4
//
// let at_end =
// match chars.peek() {
// Some(&'\r') | Some(&'\n') | None => true,
// _ => false
// };
// match next_char {
// '0' ... '9' =>
// self.read_number(),
// 'a' ... 'z' | 'A' ... 'Z' =>
// self.read_word(),
// ' ' | '\t' | '\n' =>
// self.skip_whitespace(),
// _ =>
// self.handle_punctuation()
// }
//
// 10.2.5
//
// match robot.last_known_location() {
// Some(point) if self.distance_to(point) < 10 =>
// short_distance_strategy(point),
// Some(point) ->
// long_distance_strategy(point),
// None ->
// searching_strategy()
// }
//
// 10.2.6
//
// match self.get_selection() {
// Shape::Rect(top_left, bottom_right) ->
// optimized_paint(&Shape::Rect(top_left, bottom_right)),
// other_shape =>
// paint_outline(other_shape.get_outline()),
// }
//
// rect @ Shape::Rect(..) -> optimized_paint(&rect)
//
// match chars.next() {
// Some(digit @ '0' ... '9') => read_number(disit, chars),
// }
//
// 10.2.7
//
// // ...unpack a struct into three new local variables
// let Track { album, track_number, title, ..} = song;
//
// // ...unpack a function argument that's a tuple
// fn distance_to((x,y): (f64, f64)) -> f64 { ... }
//
// // ...iterate over keys and values of a HashMap
// for (id, document) in &cache_map {
// println!("Document #{}: {}", id, document.title);
// }
//
// // ...automatically dereference an argument to a closure
// // (handy because sometimes other code passes you a reference
// // when you'd rather have a copy)
// let sum = numbers.fold(0, |a, &num| a + num);
//
// // ...handle just one enum variant specially
// if let RoughTime::InTheFuture(_, _) = user.date_of_birth() {
// user.set_time_traveler(true);
// }
//
// // ...run some code only if a table lookup succeeds
// if let Some(document) = cache_map.get(&id) {
// return send_cached_response(document);
// }
//
// // ...repeatedly try something until it succeeds
// while let Err(err) = present_cheesy_anti_robot_task() {
// log_robot_attempt(err);
// // let the user try again (it might still be a human)
// }
//
// // ...manually loop over an iterator
// while let Some(_) = lines.peek() {
// read_paragraph(&mut lines);
// }
//
// 10.2.8
impl<T: Ord> BinaryTree<T> {
fn add(&mut self, value: T) {
match *self {
BinaryTree::Empty => {
*self = BinaryTree::NonEmpty(Box::new(TreeNode {
element: value,
left: BinaryTree::Empty,
right: BinaryTree::Empty,
}))
}
BinaryTree::NonEmpty(ref mut node) => {
if value <= node.element {
node.left.add(value);
} else {
node.right.add(value);
}
}
}
}
}
let mut add_tree = BinaryTree::Empty;
add_tree.add("Mercury");
add_tree.add("Venus");
}
| 479
|
pub fn run() {
let result = is_permutation("abc", "cba");
println!("Result: {}", result);
}
| 480
|
fn item_repo_over_named_user_query() {
let dir = TestDir::new("sit", "repo_over_named_user_query");
dir.cmd()
.arg("init")
.expect_success();
dir.create_file(".sit/reducers/test.js",r#"
module.exports = function(state, record) {
return Object.assign(state, {value: "hello"});
}
"#);
let id = String::from_utf8(dir.cmd().arg("item").expect_success().stdout).unwrap();
// create a record
Repository::open(dir.path(".sit")).unwrap().item(id.trim()).unwrap().new_record(vec![("test", &b""[..])].into_iter(), true).unwrap();
let cfg = r#"{"items": {"queries": {"q1": "join(' ', ['item', id])"}}}"#;
user_config(&dir, cfg);
dir.create_file(".sit/.items/queries/q1", "join(' ', ['item', id, value])");
let output = String::from_utf8(dir.cmd()
.env("HOME", dir.path(".").to_str().unwrap())
.env("USERPROFILE", dir.path(".").to_str().unwrap())
.args(&["reduce", id.trim(), "-Q", "q1"]).expect_success().stdout).unwrap();
assert_eq!(output.trim(), format!("item {} hello", id.trim()));
}
| 481
|
async fn next_page(host: &str, page: Option<i32>) -> BinaryEdgeResponse {
dotenv().ok();
let uri = build_url(host, page);
let api_key = env::var("BINARYEDGE_TOKEN")
.expect("BINARYEDGE_TOKEN must be set in order to use Binaryedge as a data source");
surf::get(uri)
.set_header("X-Key", api_key)
.recv_json()
.await
.unwrap()
}
| 482
|
fn a_table_should_preserve_the_money_supply() {
let mut table = HashMapOfTreeMap::new();
broker(&mut table, 1000);
expect_money_conserved(&table);
}
| 483
|
fn assert_schema_is_the_same(
rule_name: &str,
prev_plan: &LogicalPlan,
new_plan: &LogicalPlan,
) -> Result<()> {
let equivalent = new_plan
.schema()
.equivalent_names_and_types(prev_plan.schema());
if !equivalent {
let e = DataFusionError::Internal(format!(
"Optimizer rule '{}' failed, due to generate a different schema, original schema: {:?}, new schema: {:?}",
rule_name,
prev_plan.schema(),
new_plan.schema()
));
Err(DataFusionError::Context(
String::from(rule_name),
Box::new(e),
))
} else {
Ok(())
}
}
| 484
|
pub fn print(buffer: [u8; 32], size: usize) {
let _ = system_call(SystemCall::Print {
request: (buffer, size)
});
}
| 485
|
fn main() {
gtk::init();
let mut window = gtk::Window::new(gtk::WindowType::TopLevel).unwrap();
window.set_title("TreeView Sample");
window.set_window_position(gtk::WindowPosition::Center);
Connect::connect(&window, DeleteEvent::new(&mut |_| {
gtk::main_quit();
true
}));
// test Value
let hello = String::from("Hello world !");
let value = glib::Value::new().unwrap();
value.init(glib::Type::String);
value.set(&hello);
println!("gvalue.get example : {}", value.get::<String>());
// left pane
let mut left_tree = gtk::TreeView::new().unwrap();
let column_types = [glib::Type::String];
let left_store = gtk::ListStore::new(&column_types).unwrap();
let left_model = left_store.get_model().unwrap();
left_tree.set_model(&left_model);
left_tree.set_headers_visible(false);
append_text_column(&mut left_tree);
for _ in 0..10 {
let mut iter = gtk::TreeIter::new().unwrap();
left_store.append(&mut iter);
left_store.set_string(&iter, 0, "I'm in a list");
}
// right pane
let mut right_tree = gtk::TreeView::new().unwrap();
let column_types = [glib::Type::String];
let right_store = gtk::TreeStore::new(&column_types).unwrap();
let right_model = right_store.get_model().unwrap();
right_tree.set_model(&right_model);
right_tree.set_headers_visible(false);
append_text_column(&mut right_tree);
for _ in 0..10 {
let mut iter = gtk::TreeIter::new().unwrap();
right_store.append(&mut iter, None);
right_store.set_value(&iter, 0, &value);
let mut child_iter = gtk::TreeIter::new().unwrap();
right_store.append(&mut child_iter, Some(&iter));
right_store.set_string(&child_iter, 0, "I'm a child node");
}
// display the panes
let mut split_pane = gtk::Box::new(gtk::Orientation::Horizontal, 10).unwrap();
split_pane.set_size_request(-1, -1);
split_pane.add(&left_tree);
split_pane.add(&right_tree);
window.add(&split_pane);
window.show_all();
gtk::main();
}
| 486
|
fn main() {
if let Err(err) = run() {
eprintln!("Error: {}", err);
let mut cur = &*err;
while let Some(cause) = cur.source() {
eprintln!("\tcaused by: {}", cause);
cur = cause;
}
std::mem::drop(cur);
std::process::exit(1);
}
}
| 487
|
pub fn challenge_9() {
let data = "YELLOW SUBMARINE".as_bytes().to_vec();
let out = crypto::pkcs7_padding(&data, 20);
println!("{}", hex::encode(&out));
assert_eq!(out.len(), 20);
assert_eq!(hex::encode(&out), "59454c4c4f57205355424d4152494e4504040404");
}
| 488
|
fn copy_icons(settings: &Settings) -> crate::Result<PathBuf> {
let base_dir = settings.project_out_directory();
let resource_dir = base_dir.join("resources");
let mut image_path = PathBuf::from(settings.project_out_directory());
// pop off till in tauri_src dir
image_path.pop();
image_path.pop();
// get icon dir and icon file.
let image_path = image_path.join("icons");
let opts = super::path_utils::Options::default();
copy(
image_path,
&resource_dir,
&Options {
copy_files: true,
overwrite: true,
..opts
},
)?;
Ok(resource_dir)
}
| 489
|
pub fn benchmark(c: &mut Criterion) {
const EXPRESSION: &str = include_str!("./expression.js");
c.bench_function("parse_expression", |b| {
b.iter_batched(
|| {
let source = Source::from_string(EXPRESSION.to_string());
let atoms = Atoms::new();
(source, atoms)
},
|x| {
let (source, atoms) = x;
let mut interner = Interner::new(&atoms);
let lexer = lexer::Lexer::new(&source, &mut interner);
let mut symbol_table = SymbolTable::new();
black_box(Parser::parse_script(lexer, &mut symbol_table, Global).unwrap());
},
BatchSize::SmallInput,
)
});
}
| 490
|
fn handle_task(client: &mut Client, main_out_c: Sender<String>) {
let (channel_out, channel_in) = unbounded();
let task_types = TaskCommandTypes::new();
// walk over the task queue. For any task_queue.state == 0, handle it.
for task in &mut client.task_queue {
// all tasks will have at least 1 iteration, but may have more. We also may have a sleep
// between iterations
let duration = (task.iteration_delay * 1000) as u64;
let sleep_duration = time::Duration::from_millis(duration);
for _iteration in 0..task.iterations {
let task_type = task_types.determine_task_type(task.command_type);
if task_type == "filesystem" {
// start the filesystem thread and go go go
let out_c = channel_out.clone();
filesystem::handle_filesystem(task, out_c);
task.state = 1;
}
// peek into the channel from our thread to see if there is data
// if there is, send it back
if let Ok(resp_from_thread) = channel_in.try_recv() {
println!("handle_task got something: {}", &resp_from_thread);
// should send the task ID back out if successful. Otherwise, an err string
main_out_c.send(resp_from_thread).unwrap();
task.state = 2;
}
thread::sleep(sleep_duration);
}
}
}
| 491
|
pub extern "x86-interrupt" fn device_not_avalidable() { CommonExceptionHandler( 7); }
| 492
|
fn docker_metric_entry_from_two_stats(time_diff: Duration, first: InstantDockerContainerMetricEntry, second: InstantDockerContainerMetricEntry) -> DockerContainerMetricEntry {
let diff = time_diff.num_milliseconds() as f64 / 1000.0; // seconds
DockerContainerMetricEntry {
name: second.name,
state: second.state,
cpu_usage: ((second.cpu_usage - first.cpu_usage) as f64 / (second.system_cpu_usage - first.system_cpu_usage) as f64) / diff,
memory_usage: second.memory_usage,
memory_cache: second.memory_cache,
network_tx: (second.network_tx - first.network_tx) as f64 / diff,
network_rx: (second.network_rx - first.network_rx) as f64 / diff
}
}
| 493
|
async fn main() -> std::io::Result<()> {
// Set keep-alive to 75 seconds
let _one = HttpServer::new(app).keep_alive(Duration::from_secs(75));
// Use OS's keep-alive (usually quite long)
let _two = HttpServer::new(app).keep_alive(KeepAlive::Os);
// Disable keep-alive
let _three = HttpServer::new(app).keep_alive(None);
Ok(())
}
| 494
|
fn foreign_keys_are_preserved_when_generating_data_model_from_a_schema() {
let ref_data_model = Datamodel {
models: vec![
Model {
database_name: None,
name: "City".to_string(),
documentation: None,
is_embedded: false,
is_commented_out: false,
fields: vec![
Field::ScalarField(ScalarField {
name: "id".to_string(),
arity: FieldArity::Required,
field_type: FieldType::Base(ScalarType::Int, None),
database_name: None,
default_value: Some(DMLDefault::Expression(ValueGenerator::new_autoincrement())),
is_unique: false,
is_id: true,
documentation: None,
is_generated: false,
is_updated_at: false,
is_commented_out: false,
}),
Field::ScalarField(ScalarField::new(
"name",
FieldArity::Required,
FieldType::Base(ScalarType::String, None),
)),
Field::RelationField(RelationField::new(
"User",
FieldArity::List,
RelationInfo {
to: "User".to_string(),
fields: vec![],
to_fields: vec![],
name: "CityToUser".to_string(),
on_delete: OnDeleteStrategy::None,
},
)),
],
is_generated: false,
indices: vec![],
id_fields: vec![],
},
Model {
database_name: None,
name: "User".to_string(),
documentation: None,
is_embedded: false,
is_commented_out: false,
fields: vec![
Field::ScalarField(ScalarField {
name: "id".to_string(),
arity: FieldArity::Required,
field_type: FieldType::Base(ScalarType::Int, None),
database_name: None,
default_value: Some(DMLDefault::Expression(ValueGenerator::new_autoincrement())),
is_unique: false,
is_id: true,
documentation: None,
is_generated: false,
is_updated_at: false,
is_commented_out: false,
}),
Field::ScalarField(ScalarField::new(
"city_id",
FieldArity::Required,
FieldType::Base(ScalarType::Int, None),
)),
Field::RelationField(RelationField::new(
"City",
FieldArity::Required,
RelationInfo {
name: "CityToUser".to_string(),
to: "City".to_string(),
fields: vec!["city_id".to_string()],
to_fields: vec!["id".to_string()],
on_delete: OnDeleteStrategy::None,
},
)),
],
is_generated: false,
indices: vec![],
id_fields: vec![],
},
],
enums: vec![],
};
let schema = SqlSchema {
tables: vec![
Table {
name: "City".to_string(),
columns: vec![
Column {
name: "id".to_string(),
tpe: ColumnType {
data_type: "integer".to_string(),
full_data_type: "integer".to_string(),
character_maximum_length: None,
family: ColumnTypeFamily::Int,
arity: ColumnArity::Required,
},
default: None,
auto_increment: true,
},
Column {
name: "name".to_string(),
tpe: ColumnType {
data_type: "text".to_string(),
full_data_type: "text".to_string(),
character_maximum_length: None,
family: ColumnTypeFamily::String,
arity: ColumnArity::Required,
},
default: None,
auto_increment: false,
},
],
indices: vec![],
primary_key: Some(PrimaryKey {
columns: vec!["id".to_string()],
sequence: None,
constraint_name: None,
}),
foreign_keys: vec![],
},
Table {
name: "User".to_string(),
columns: vec![
Column {
name: "id".to_string(),
tpe: ColumnType {
data_type: "integer".to_string(),
full_data_type: "integer".to_string(),
character_maximum_length: None,
family: ColumnTypeFamily::Int,
arity: ColumnArity::Required,
},
default: None,
auto_increment: true,
},
Column {
name: "city_id".to_string(),
tpe: ColumnType {
data_type: "integer".to_string(),
full_data_type: "integer".to_string(),
character_maximum_length: None,
family: ColumnTypeFamily::Int,
arity: ColumnArity::Required,
},
default: None,
auto_increment: false,
},
],
indices: vec![],
primary_key: Some(PrimaryKey {
columns: vec!["id".to_string()],
sequence: None,
constraint_name: None,
}),
foreign_keys: vec![ForeignKey {
constraint_name: None,
columns: vec!["city_id".to_string()],
referenced_table: "City".to_string(),
on_delete_action: ForeignKeyAction::NoAction,
referenced_columns: vec!["id".to_string()],
}],
},
],
enums: vec![],
sequences: vec![],
};
let introspection_result = calculate_datamodel(&schema, &SqlFamily::Postgres).expect("calculate data model");
assert_eq!(introspection_result.data_model, ref_data_model);
}
| 495
|
fn inc_24() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Indirect(RCX, Some(OperandSize::Dword), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[255, 1], OperandSize::Qword)
}
| 496
|
pub fn new_cube() -> Tess {
let vertices: &[([f32; 3], [f32; 3], [f32; 2])] = &[
// front face
([ 1., -1., 1.], [ 0., 0., 1.], [1., 0.]), // 0
([ 1., 1., 1.], [ 0., 0., 1.], [1., 1.]),
([-1., -1., 1.], [ 0., 0., 1.], [0., 0.]),
([-1., 1., 1.], [ 0., 0., 1.], [0., 1.]),
// back face
([ 1., -1., -1.], [ 0., 0., -1.], [1., 0.]), // 4
([ 1., 1., -1.], [ 0., 0., -1.], [1., 1.]),
([-1., -1., -1.], [ 0., 0., -1.], [0., 0.]),
([-1., 1., -1.], [ 0., 0., -1.], [0., 1.]),
// left face
([-1., -1., 1.], [-1., 0., 0.], [1., 0.]), // 8
([-1., 1., 1.], [-1., 0., 0.], [1., 1.]),
([-1., -1., -1.], [-1., 0., 0.], [0., 0.]),
([-1., 1., -1.], [-1., 0., 0.], [0., 1.]),
// right face
([ 1., -1., -1.], [ 1., 0., 0.], [1., 0.]), // 12
([ 1., 1., -1.], [ 1., 0., 0.], [1., 1.]),
([ 1., -1., 1.], [ 1., 0., 0.], [0., 0.]),
([ 1., 1., 1.], [ 1., 0., 0.], [0., 1.]),
// top face
([ 1., 1., 1.], [ 0., 1., 0.], [1., 0.]), // 16
([ 1., 1., -1.], [ 0., 1., 0.], [1., 1.]),
([-1., 1., 1.], [ 0., 1., 0.], [0., 0.]),
([-1., 1., -1.], [ 0., 1., 0.], [0., 1.]),
// bottom face
([ 1., -1., -1.], [ 0., -1., 0.], [1., 0.]), // 20
([ 1., -1., 1.], [ 0., -1., 0.], [1., 1.]),
([-1., -1., -1.], [ 0., -1., 0.], [0., 0.]),
([-1., -1., 1.], [ 0., -1., 0.], [0., 1.]),
];
let indices: &[u32] = &[
0, 1, 2, 2, 1, 3, // front face
4, 5, 6, 6, 5, 7, // back face
8, 9, 10, 10, 9, 11, // left face
12, 13, 14, 14, 13, 15, // right face
16, 17, 18, 18, 17, 19, // top face
20, 21, 22, 22, 21, 23, // bottom face
];
Tess::new(Mode::Triangle, TessVertices::Fill(vertices), indices)
}
| 497
|
pub fn write_i8<W>(wr: &mut W, val: i8) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_marker(wr, Marker::I8));
write_data_i8(wr, val)
}
| 498
|
pub fn causet_partitioner_scan(
request: Box<CausetPartitionerRequest>,
result: Box<CausetPartitionerResult>,
) -> Box<CausetPartitionerResult> {
result
}
| 499
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.